Layer.cpp revision 98b0fd5fc28b07b6b488bc599a3448ebcacb6acc
1/* 2 * Copyright (C) 2007 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 "Layer" 20#define ATRACE_TAG ATRACE_TAG_GRAPHICS 21 22#include <stdlib.h> 23#include <stdint.h> 24#include <sys/types.h> 25#include <math.h> 26 27#include <cutils/compiler.h> 28#include <cutils/native_handle.h> 29#include <cutils/properties.h> 30 31#include <utils/Errors.h> 32#include <utils/Log.h> 33#include <utils/NativeHandle.h> 34#include <utils/StopWatch.h> 35#include <utils/Trace.h> 36 37#include <ui/GraphicBuffer.h> 38#include <ui/PixelFormat.h> 39 40#include <gui/BufferItem.h> 41#include <gui/BufferQueue.h> 42#include <gui/Surface.h> 43 44#include "clz.h" 45#include "Colorizer.h" 46#include "DisplayDevice.h" 47#include "Layer.h" 48#include "LayerRejecter.h" 49#include "MonitoredProducer.h" 50#include "SurfaceFlinger.h" 51 52#include "DisplayHardware/HWComposer.h" 53 54#include "RenderEngine/RenderEngine.h" 55 56#include <mutex> 57 58#define DEBUG_RESIZE 0 59 60namespace android { 61 62// --------------------------------------------------------------------------- 63 64int32_t Layer::sSequence = 1; 65 66Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client, 67 const String8& name, uint32_t w, uint32_t h, uint32_t flags) 68 : contentDirty(false), 69 sequence(uint32_t(android_atomic_inc(&sSequence))), 70 mFlinger(flinger), 71 mTextureName(-1U), 72 mPremultipliedAlpha(true), 73 mName("unnamed"), 74 mFormat(PIXEL_FORMAT_NONE), 75 mTransactionFlags(0), 76 mPendingStateMutex(), 77 mPendingStates(), 78 mQueuedFrames(0), 79 mSidebandStreamChanged(false), 80 mActiveBufferSlot(BufferQueue::INVALID_BUFFER_SLOT), 81 mCurrentTransform(0), 82 mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), 83 mOverrideScalingMode(-1), 84 mCurrentOpacity(true), 85 mBufferLatched(false), 86 mCurrentFrameNumber(0), 87 mPreviousFrameNumber(0), 88 mRefreshPending(false), 89 mFrameLatencyNeeded(false), 90 mFiltering(false), 91 mNeedsFiltering(false), 92 mMesh(Mesh::TRIANGLE_FAN, 4, 2, 2), 93#ifndef USE_HWC2 94 mIsGlesComposition(false), 95#endif 96 mProtectedByApp(false), 97 mHasSurface(false), 98 mClientRef(client), 99 mPotentialCursor(false), 100 mQueueItemLock(), 101 mQueueItemCondition(), 102 mQueueItems(), 103 mLastFrameNumberReceived(0), 104 mUpdateTexImageFailed(false), 105 mAutoRefresh(false), 106 mFreezeGeometryUpdates(false) 107{ 108#ifdef USE_HWC2 109 ALOGV("Creating Layer %s", name.string()); 110#endif 111 112 mCurrentCrop.makeInvalid(); 113 mFlinger->getRenderEngine().genTextures(1, &mTextureName); 114 mTexture.init(Texture::TEXTURE_EXTERNAL, mTextureName); 115 116 uint32_t layerFlags = 0; 117 if (flags & ISurfaceComposerClient::eHidden) 118 layerFlags |= layer_state_t::eLayerHidden; 119 if (flags & ISurfaceComposerClient::eOpaque) 120 layerFlags |= layer_state_t::eLayerOpaque; 121 if (flags & ISurfaceComposerClient::eSecure) 122 layerFlags |= layer_state_t::eLayerSecure; 123 124 if (flags & ISurfaceComposerClient::eNonPremultiplied) 125 mPremultipliedAlpha = false; 126 127 mName = name; 128 129 mCurrentState.active.w = w; 130 mCurrentState.active.h = h; 131 mCurrentState.active.transform.set(0, 0); 132 mCurrentState.crop.makeInvalid(); 133 mCurrentState.finalCrop.makeInvalid(); 134 mCurrentState.requestedFinalCrop = mCurrentState.finalCrop; 135 mCurrentState.requestedCrop = mCurrentState.crop; 136 mCurrentState.z = 0; 137#ifdef USE_HWC2 138 mCurrentState.alpha = 1.0f; 139#else 140 mCurrentState.alpha = 0xFF; 141#endif 142 mCurrentState.layerStack = 0; 143 mCurrentState.flags = layerFlags; 144 mCurrentState.sequence = 0; 145 mCurrentState.requested = mCurrentState.active; 146 mCurrentState.dataSpace = HAL_DATASPACE_UNKNOWN; 147 mCurrentState.appId = 0; 148 mCurrentState.type = 0; 149 150 // drawing state & current state are identical 151 mDrawingState = mCurrentState; 152 153#ifdef USE_HWC2 154 const auto& hwc = flinger->getHwComposer(); 155 const auto& activeConfig = hwc.getActiveConfig(HWC_DISPLAY_PRIMARY); 156 nsecs_t displayPeriod = activeConfig->getVsyncPeriod(); 157#else 158 nsecs_t displayPeriod = 159 flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 160#endif 161 mFrameTracker.setDisplayRefreshPeriod(displayPeriod); 162 163 CompositorTiming compositorTiming; 164 flinger->getCompositorTiming(&compositorTiming); 165 mFrameEventHistory.initializeCompositorTiming(compositorTiming); 166} 167 168void Layer::onFirstRef() { 169 // Creates a custom BufferQueue for SurfaceFlingerConsumer to use 170 sp<IGraphicBufferProducer> producer; 171 sp<IGraphicBufferConsumer> consumer; 172 BufferQueue::createBufferQueue(&producer, &consumer, true); 173 mProducer = new MonitoredProducer(producer, mFlinger, this); 174 mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName, this); 175 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 176 mSurfaceFlingerConsumer->setContentsChangedListener(this); 177 mSurfaceFlingerConsumer->setName(mName); 178 179 if (mFlinger->isLayerTripleBufferingDisabled()) { 180 mProducer->setMaxDequeuedBufferCount(2); 181 } 182 183 const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); 184 updateTransformHint(hw); 185} 186 187Layer::~Layer() { 188 sp<Client> c(mClientRef.promote()); 189 if (c != 0) { 190 c->detachLayer(this); 191 } 192 193 for (auto& point : mRemoteSyncPoints) { 194 point->setTransactionApplied(); 195 } 196 for (auto& point : mLocalSyncPoints) { 197 point->setFrameAvailable(); 198 } 199 mFlinger->deleteTextureAsync(mTextureName); 200 mFrameTracker.logAndResetStats(mName); 201} 202 203// --------------------------------------------------------------------------- 204// callbacks 205// --------------------------------------------------------------------------- 206 207#ifdef USE_HWC2 208void Layer::onLayerDisplayed(const sp<Fence>& releaseFence) { 209 if (mHwcLayers.empty()) { 210 return; 211 } 212 mSurfaceFlingerConsumer->setReleaseFence(releaseFence); 213} 214#else 215void Layer::onLayerDisplayed(const sp<const DisplayDevice>& /* hw */, 216 HWComposer::HWCLayerInterface* layer) { 217 if (layer) { 218 layer->onDisplayed(); 219 mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFence()); 220 } 221} 222#endif 223 224void Layer::onFrameAvailable(const BufferItem& item) { 225 // Add this buffer from our internal queue tracker 226 { // Autolock scope 227 Mutex::Autolock lock(mQueueItemLock); 228 mFlinger->mInterceptor.saveBufferUpdate(this, item.mGraphicBuffer->getWidth(), 229 item.mGraphicBuffer->getHeight(), item.mFrameNumber); 230 // Reset the frame number tracker when we receive the first buffer after 231 // a frame number reset 232 if (item.mFrameNumber == 1) { 233 mLastFrameNumberReceived = 0; 234 } 235 236 // Ensure that callbacks are handled in order 237 while (item.mFrameNumber != mLastFrameNumberReceived + 1) { 238 status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, 239 ms2ns(500)); 240 if (result != NO_ERROR) { 241 ALOGE("[%s] Timed out waiting on callback", mName.string()); 242 } 243 } 244 245 mQueueItems.push_back(item); 246 android_atomic_inc(&mQueuedFrames); 247 248 // Wake up any pending callbacks 249 mLastFrameNumberReceived = item.mFrameNumber; 250 mQueueItemCondition.broadcast(); 251 } 252 253 mFlinger->signalLayerUpdate(); 254} 255 256void Layer::onFrameReplaced(const BufferItem& item) { 257 { // Autolock scope 258 Mutex::Autolock lock(mQueueItemLock); 259 260 // Ensure that callbacks are handled in order 261 while (item.mFrameNumber != mLastFrameNumberReceived + 1) { 262 status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, 263 ms2ns(500)); 264 if (result != NO_ERROR) { 265 ALOGE("[%s] Timed out waiting on callback", mName.string()); 266 } 267 } 268 269 if (mQueueItems.empty()) { 270 ALOGE("Can't replace a frame on an empty queue"); 271 return; 272 } 273 mQueueItems.editItemAt(mQueueItems.size() - 1) = item; 274 275 // Wake up any pending callbacks 276 mLastFrameNumberReceived = item.mFrameNumber; 277 mQueueItemCondition.broadcast(); 278 } 279} 280 281void Layer::onSidebandStreamChanged() { 282 if (android_atomic_release_cas(false, true, &mSidebandStreamChanged) == 0) { 283 // mSidebandStreamChanged was false 284 mFlinger->signalLayerUpdate(); 285 } 286} 287 288// called with SurfaceFlinger::mStateLock from the drawing thread after 289// the layer has been remove from the current state list (and just before 290// it's removed from the drawing state list) 291void Layer::onRemoved() { 292 if (mCurrentState.zOrderRelativeOf != nullptr) { 293 sp<Layer> strongRelative = mCurrentState.zOrderRelativeOf.promote(); 294 if (strongRelative != nullptr) { 295 strongRelative->removeZOrderRelative(this); 296 } 297 mCurrentState.zOrderRelativeOf = nullptr; 298 } 299 300 mSurfaceFlingerConsumer->abandon(); 301 302#ifdef USE_HWC2 303 clearHwcLayers(); 304#endif 305 306 for (const auto& child : mCurrentChildren) { 307 child->onRemoved(); 308 } 309} 310 311// --------------------------------------------------------------------------- 312// set-up 313// --------------------------------------------------------------------------- 314 315const String8& Layer::getName() const { 316 return mName; 317} 318 319status_t Layer::setBuffers( uint32_t w, uint32_t h, 320 PixelFormat format, uint32_t flags) 321{ 322 uint32_t const maxSurfaceDims = min( 323 mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); 324 325 // never allow a surface larger than what our underlying GL implementation 326 // can handle. 327 if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) { 328 ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); 329 return BAD_VALUE; 330 } 331 332 mFormat = format; 333 334 mPotentialCursor = (flags & ISurfaceComposerClient::eCursorWindow) ? true : false; 335 mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; 336 mCurrentOpacity = getOpacityForFormat(format); 337 338 mSurfaceFlingerConsumer->setDefaultBufferSize(w, h); 339 mSurfaceFlingerConsumer->setDefaultBufferFormat(format); 340 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 341 342 return NO_ERROR; 343} 344 345sp<IBinder> Layer::getHandle() { 346 Mutex::Autolock _l(mLock); 347 348 LOG_ALWAYS_FATAL_IF(mHasSurface, 349 "Layer::getHandle() has already been called"); 350 351 mHasSurface = true; 352 353 return new Handle(mFlinger, this); 354} 355 356sp<IGraphicBufferProducer> Layer::getProducer() const { 357 return mProducer; 358} 359 360// --------------------------------------------------------------------------- 361// h/w composer set-up 362// --------------------------------------------------------------------------- 363 364Rect Layer::getContentCrop() const { 365 // this is the crop rectangle that applies to the buffer 366 // itself (as opposed to the window) 367 Rect crop; 368 if (!mCurrentCrop.isEmpty()) { 369 // if the buffer crop is defined, we use that 370 crop = mCurrentCrop; 371 } else if (mActiveBuffer != NULL) { 372 // otherwise we use the whole buffer 373 crop = mActiveBuffer->getBounds(); 374 } else { 375 // if we don't have a buffer yet, we use an empty/invalid crop 376 crop.makeInvalid(); 377 } 378 return crop; 379} 380 381static Rect reduce(const Rect& win, const Region& exclude) { 382 if (CC_LIKELY(exclude.isEmpty())) { 383 return win; 384 } 385 if (exclude.isRect()) { 386 return win.reduce(exclude.getBounds()); 387 } 388 return Region(win).subtract(exclude).getBounds(); 389} 390 391Rect Layer::computeScreenBounds(bool reduceTransparentRegion) const { 392 const Layer::State& s(getDrawingState()); 393 Rect win(s.active.w, s.active.h); 394 395 if (!s.crop.isEmpty()) { 396 win.intersect(s.crop, &win); 397 } 398 399 Transform t = getTransform(); 400 win = t.transform(win); 401 402 const sp<Layer>& p = getParent(); 403 // Now we need to calculate the parent bounds, so we can clip ourselves to those. 404 // When calculating the parent bounds for purposes of clipping, 405 // we don't need to constrain the parent to its transparent region. 406 // The transparent region is an optimization based on the 407 // buffer contents of the layer, but does not affect the space allocated to 408 // it by policy, and thus children should be allowed to extend into the 409 // parent's transparent region. In fact one of the main uses, is to reduce 410 // buffer allocation size in cases where a child window sits behind a main window 411 // (by marking the hole in the parent window as a transparent region) 412 if (p != nullptr) { 413 Rect bounds = p->computeScreenBounds(false); 414 bounds.intersect(win, &win); 415 } 416 417 if (reduceTransparentRegion) { 418 auto const screenTransparentRegion = t.transform(s.activeTransparentRegion); 419 win = reduce(win, screenTransparentRegion); 420 } 421 422 return win; 423} 424 425Rect Layer::computeBounds() const { 426 const Layer::State& s(getDrawingState()); 427 return computeBounds(s.activeTransparentRegion); 428} 429 430Rect Layer::computeBounds(const Region& activeTransparentRegion) const { 431 const Layer::State& s(getDrawingState()); 432 Rect win(s.active.w, s.active.h); 433 434 if (!s.crop.isEmpty()) { 435 win.intersect(s.crop, &win); 436 } 437 438 Rect bounds = win; 439 const auto& p = getParent(); 440 if (p != nullptr) { 441 // Look in computeScreenBounds recursive call for explanation of 442 // why we pass false here. 443 bounds = p->computeScreenBounds(false /* reduceTransparentRegion */); 444 } 445 446 Transform t = getTransform(); 447 if (p != nullptr) { 448 win = t.transform(win); 449 win.intersect(bounds, &win); 450 win = t.inverse().transform(win); 451 } 452 453 // subtract the transparent region and snap to the bounds 454 return reduce(win, activeTransparentRegion); 455} 456 457Rect Layer::computeInitialCrop(const sp<const DisplayDevice>& hw) const { 458 // the crop is the area of the window that gets cropped, but not 459 // scaled in any ways. 460 const State& s(getDrawingState()); 461 462 // apply the projection's clipping to the window crop in 463 // layerstack space, and convert-back to layer space. 464 // if there are no window scaling involved, this operation will map to full 465 // pixels in the buffer. 466 // FIXME: the 3 lines below can produce slightly incorrect clipping when we have 467 // a viewport clipping and a window transform. we should use floating point to fix this. 468 469 Rect activeCrop(s.active.w, s.active.h); 470 if (!s.crop.isEmpty()) { 471 activeCrop = s.crop; 472 } 473 474 Transform t = getTransform(); 475 activeCrop = t.transform(activeCrop); 476 if (!activeCrop.intersect(hw->getViewport(), &activeCrop)) { 477 activeCrop.clear(); 478 } 479 if (!s.finalCrop.isEmpty()) { 480 if(!activeCrop.intersect(s.finalCrop, &activeCrop)) { 481 activeCrop.clear(); 482 } 483 } 484 return activeCrop; 485} 486 487FloatRect Layer::computeCrop(const sp<const DisplayDevice>& hw) const { 488 // the content crop is the area of the content that gets scaled to the 489 // layer's size. This is in buffer space. 490 FloatRect crop = getContentCrop().toFloatRect(); 491 492 // In addition there is a WM-specified crop we pull from our drawing state. 493 const State& s(getDrawingState()); 494 495 // Screen space to make reduction to parent crop clearer. 496 Rect activeCrop = computeInitialCrop(hw); 497 const auto& p = getParent(); 498 if (p != nullptr) { 499 auto parentCrop = p->computeInitialCrop(hw); 500 activeCrop.intersect(parentCrop, &activeCrop); 501 } 502 Transform t = getTransform(); 503 // Back to layer space to work with the content crop. 504 activeCrop = t.inverse().transform(activeCrop); 505 506 // This needs to be here as transform.transform(Rect) computes the 507 // transformed rect and then takes the bounding box of the result before 508 // returning. This means 509 // transform.inverse().transform(transform.transform(Rect)) != Rect 510 // in which case we need to make sure the final rect is clipped to the 511 // display bounds. 512 if (!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) { 513 activeCrop.clear(); 514 } 515 516 // subtract the transparent region and snap to the bounds 517 activeCrop = reduce(activeCrop, s.activeTransparentRegion); 518 519 // Transform the window crop to match the buffer coordinate system, 520 // which means using the inverse of the current transform set on the 521 // SurfaceFlingerConsumer. 522 uint32_t invTransform = mCurrentTransform; 523 if (getTransformToDisplayInverse()) { 524 /* 525 * the code below applies the primary display's inverse transform to the 526 * buffer 527 */ 528 uint32_t invTransformOrient = 529 DisplayDevice::getPrimaryDisplayOrientationTransform(); 530 // calculate the inverse transform 531 if (invTransformOrient & NATIVE_WINDOW_TRANSFORM_ROT_90) { 532 invTransformOrient ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 533 NATIVE_WINDOW_TRANSFORM_FLIP_H; 534 } 535 // and apply to the current transform 536 invTransform = (Transform(invTransformOrient) * Transform(invTransform)) 537 .getOrientation(); 538 } 539 540 int winWidth = s.active.w; 541 int winHeight = s.active.h; 542 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 543 // If the activeCrop has been rotate the ends are rotated but not 544 // the space itself so when transforming ends back we can't rely on 545 // a modification of the axes of rotation. To account for this we 546 // need to reorient the inverse rotation in terms of the current 547 // axes of rotation. 548 bool is_h_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; 549 bool is_v_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; 550 if (is_h_flipped == is_v_flipped) { 551 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 552 NATIVE_WINDOW_TRANSFORM_FLIP_H; 553 } 554 winWidth = s.active.h; 555 winHeight = s.active.w; 556 } 557 const Rect winCrop = activeCrop.transform( 558 invTransform, s.active.w, s.active.h); 559 560 // below, crop is intersected with winCrop expressed in crop's coordinate space 561 float xScale = crop.getWidth() / float(winWidth); 562 float yScale = crop.getHeight() / float(winHeight); 563 564 float insetL = winCrop.left * xScale; 565 float insetT = winCrop.top * yScale; 566 float insetR = (winWidth - winCrop.right ) * xScale; 567 float insetB = (winHeight - winCrop.bottom) * yScale; 568 569 crop.left += insetL; 570 crop.top += insetT; 571 crop.right -= insetR; 572 crop.bottom -= insetB; 573 574 return crop; 575} 576 577#ifdef USE_HWC2 578void Layer::setGeometry(const sp<const DisplayDevice>& displayDevice, uint32_t z) 579#else 580void Layer::setGeometry( 581 const sp<const DisplayDevice>& hw, 582 HWComposer::HWCLayerInterface& layer) 583#endif 584{ 585#ifdef USE_HWC2 586 const auto hwcId = displayDevice->getHwcDisplayId(); 587 auto& hwcInfo = mHwcLayers[hwcId]; 588#else 589 layer.setDefaultState(); 590#endif 591 592 // enable this layer 593#ifdef USE_HWC2 594 hwcInfo.forceClientComposition = false; 595 596 if (isSecure() && !displayDevice->isSecure()) { 597 hwcInfo.forceClientComposition = true; 598 } 599 600 auto& hwcLayer = hwcInfo.layer; 601#else 602 layer.setSkip(false); 603 604 if (isSecure() && !hw->isSecure()) { 605 layer.setSkip(true); 606 } 607#endif 608 609 // this gives us only the "orientation" component of the transform 610 const State& s(getDrawingState()); 611#ifdef USE_HWC2 612 auto blendMode = HWC2::BlendMode::None; 613 if (!isOpaque(s) || getAlpha() != 1.0f) { 614 blendMode = mPremultipliedAlpha ? 615 HWC2::BlendMode::Premultiplied : HWC2::BlendMode::Coverage; 616 } 617 auto error = hwcLayer->setBlendMode(blendMode); 618 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set blend mode %s:" 619 " %s (%d)", mName.string(), to_string(blendMode).c_str(), 620 to_string(error).c_str(), static_cast<int32_t>(error)); 621#else 622 if (!isOpaque(s) || getAlpha() != 0xFF) { 623 layer.setBlending(mPremultipliedAlpha ? 624 HWC_BLENDING_PREMULT : 625 HWC_BLENDING_COVERAGE); 626 } 627#endif 628 629 // apply the layer's transform, followed by the display's global transform 630 // here we're guaranteed that the layer's transform preserves rects 631 Region activeTransparentRegion(s.activeTransparentRegion); 632 Transform t = getTransform(); 633 if (!s.crop.isEmpty()) { 634 Rect activeCrop(s.crop); 635 activeCrop = t.transform(activeCrop); 636#ifdef USE_HWC2 637 if(!activeCrop.intersect(displayDevice->getViewport(), &activeCrop)) { 638#else 639 if(!activeCrop.intersect(hw->getViewport(), &activeCrop)) { 640#endif 641 activeCrop.clear(); 642 } 643 activeCrop = t.inverse().transform(activeCrop, true); 644 // This needs to be here as transform.transform(Rect) computes the 645 // transformed rect and then takes the bounding box of the result before 646 // returning. This means 647 // transform.inverse().transform(transform.transform(Rect)) != Rect 648 // in which case we need to make sure the final rect is clipped to the 649 // display bounds. 650 if(!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) { 651 activeCrop.clear(); 652 } 653 // mark regions outside the crop as transparent 654 activeTransparentRegion.orSelf(Rect(0, 0, s.active.w, activeCrop.top)); 655 activeTransparentRegion.orSelf(Rect(0, activeCrop.bottom, 656 s.active.w, s.active.h)); 657 activeTransparentRegion.orSelf(Rect(0, activeCrop.top, 658 activeCrop.left, activeCrop.bottom)); 659 activeTransparentRegion.orSelf(Rect(activeCrop.right, activeCrop.top, 660 s.active.w, activeCrop.bottom)); 661 } 662 663 Rect frame(t.transform(computeBounds(activeTransparentRegion))); 664 if (!s.finalCrop.isEmpty()) { 665 if(!frame.intersect(s.finalCrop, &frame)) { 666 frame.clear(); 667 } 668 } 669#ifdef USE_HWC2 670 if (!frame.intersect(displayDevice->getViewport(), &frame)) { 671 frame.clear(); 672 } 673 const Transform& tr(displayDevice->getTransform()); 674 Rect transformedFrame = tr.transform(frame); 675 error = hwcLayer->setDisplayFrame(transformedFrame); 676 if (error != HWC2::Error::None) { 677 ALOGE("[%s] Failed to set display frame [%d, %d, %d, %d]: %s (%d)", 678 mName.string(), transformedFrame.left, transformedFrame.top, 679 transformedFrame.right, transformedFrame.bottom, 680 to_string(error).c_str(), static_cast<int32_t>(error)); 681 } else { 682 hwcInfo.displayFrame = transformedFrame; 683 } 684 685 FloatRect sourceCrop = computeCrop(displayDevice); 686 error = hwcLayer->setSourceCrop(sourceCrop); 687 if (error != HWC2::Error::None) { 688 ALOGE("[%s] Failed to set source crop [%.3f, %.3f, %.3f, %.3f]: " 689 "%s (%d)", mName.string(), sourceCrop.left, sourceCrop.top, 690 sourceCrop.right, sourceCrop.bottom, to_string(error).c_str(), 691 static_cast<int32_t>(error)); 692 } else { 693 hwcInfo.sourceCrop = sourceCrop; 694 } 695 696 float alpha = getAlpha(); 697 error = hwcLayer->setPlaneAlpha(alpha); 698 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set plane alpha %.3f: " 699 "%s (%d)", mName.string(), alpha, to_string(error).c_str(), 700 static_cast<int32_t>(error)); 701 702 error = hwcLayer->setZOrder(z); 703 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set Z %u: %s (%d)", 704 mName.string(), z, to_string(error).c_str(), 705 static_cast<int32_t>(error)); 706 707 int type = s.type; 708 int appId = s.appId; 709 sp<Layer> parent = mParent.promote(); 710 if (parent.get()) { 711 auto& parentState = parent->getDrawingState(); 712 type = parentState.type; 713 appId = parentState.appId; 714 } 715 716 error = hwcLayer->setInfo(type, appId); 717 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set info (%d)", 718 mName.string(), static_cast<int32_t>(error)); 719#else 720 if (!frame.intersect(hw->getViewport(), &frame)) { 721 frame.clear(); 722 } 723 const Transform& tr(hw->getTransform()); 724 layer.setFrame(tr.transform(frame)); 725 layer.setCrop(computeCrop(hw)); 726 layer.setPlaneAlpha(getAlpha()); 727#endif 728 729 /* 730 * Transformations are applied in this order: 731 * 1) buffer orientation/flip/mirror 732 * 2) state transformation (window manager) 733 * 3) layer orientation (screen orientation) 734 * (NOTE: the matrices are multiplied in reverse order) 735 */ 736 737 const Transform bufferOrientation(mCurrentTransform); 738 Transform transform(tr * t * bufferOrientation); 739 740 if (getTransformToDisplayInverse()) { 741 /* 742 * the code below applies the primary display's inverse transform to the 743 * buffer 744 */ 745 uint32_t invTransform = 746 DisplayDevice::getPrimaryDisplayOrientationTransform(); 747 // calculate the inverse transform 748 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 749 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 750 NATIVE_WINDOW_TRANSFORM_FLIP_H; 751 } 752 753 /* 754 * Here we cancel out the orientation component of the WM transform. 755 * The scaling and translate components are already included in our bounds 756 * computation so it's enough to just omit it in the composition. 757 * See comment in onDraw with ref to b/36727915 for why. 758 */ 759 transform = Transform(invTransform) * tr * bufferOrientation; 760 } 761 762 // this gives us only the "orientation" component of the transform 763 const uint32_t orientation = transform.getOrientation(); 764#ifdef USE_HWC2 765 if (orientation & Transform::ROT_INVALID) { 766 // we can only handle simple transformation 767 hwcInfo.forceClientComposition = true; 768 } else { 769 auto transform = static_cast<HWC2::Transform>(orientation); 770 auto error = hwcLayer->setTransform(transform); 771 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set transform %s: " 772 "%s (%d)", mName.string(), to_string(transform).c_str(), 773 to_string(error).c_str(), static_cast<int32_t>(error)); 774 } 775#else 776 if (orientation & Transform::ROT_INVALID) { 777 // we can only handle simple transformation 778 layer.setSkip(true); 779 } else { 780 layer.setTransform(orientation); 781 } 782#endif 783} 784 785#ifdef USE_HWC2 786void Layer::forceClientComposition(int32_t hwcId) { 787 if (mHwcLayers.count(hwcId) == 0) { 788 ALOGE("forceClientComposition: no HWC layer found (%d)", hwcId); 789 return; 790 } 791 792 mHwcLayers[hwcId].forceClientComposition = true; 793} 794 795void Layer::setPerFrameData(const sp<const DisplayDevice>& displayDevice) { 796 // Apply this display's projection's viewport to the visible region 797 // before giving it to the HWC HAL. 798 const Transform& tr = displayDevice->getTransform(); 799 const auto& viewport = displayDevice->getViewport(); 800 Region visible = tr.transform(visibleRegion.intersect(viewport)); 801 auto hwcId = displayDevice->getHwcDisplayId(); 802 auto& hwcInfo = mHwcLayers[hwcId]; 803 auto& hwcLayer = hwcInfo.layer; 804 auto error = hwcLayer->setVisibleRegion(visible); 805 if (error != HWC2::Error::None) { 806 ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(), 807 to_string(error).c_str(), static_cast<int32_t>(error)); 808 visible.dump(LOG_TAG); 809 } 810 811 error = hwcLayer->setSurfaceDamage(surfaceDamageRegion); 812 if (error != HWC2::Error::None) { 813 ALOGE("[%s] Failed to set surface damage: %s (%d)", mName.string(), 814 to_string(error).c_str(), static_cast<int32_t>(error)); 815 surfaceDamageRegion.dump(LOG_TAG); 816 } 817 818 // Sideband layers 819 if (mSidebandStream.get()) { 820 setCompositionType(hwcId, HWC2::Composition::Sideband); 821 ALOGV("[%s] Requesting Sideband composition", mName.string()); 822 error = hwcLayer->setSidebandStream(mSidebandStream->handle()); 823 if (error != HWC2::Error::None) { 824 ALOGE("[%s] Failed to set sideband stream %p: %s (%d)", 825 mName.string(), mSidebandStream->handle(), 826 to_string(error).c_str(), static_cast<int32_t>(error)); 827 } 828 return; 829 } 830 831 // Client layers 832 if (hwcInfo.forceClientComposition || 833 (mActiveBuffer != nullptr && mActiveBuffer->handle == nullptr)) { 834 ALOGV("[%s] Requesting Client composition", mName.string()); 835 setCompositionType(hwcId, HWC2::Composition::Client); 836 return; 837 } 838 839 // SolidColor layers 840 if (mActiveBuffer == nullptr) { 841 setCompositionType(hwcId, HWC2::Composition::SolidColor); 842 843 // For now, we only support black for DimLayer 844 error = hwcLayer->setColor({0, 0, 0, 255}); 845 if (error != HWC2::Error::None) { 846 ALOGE("[%s] Failed to set color: %s (%d)", mName.string(), 847 to_string(error).c_str(), static_cast<int32_t>(error)); 848 } 849 850 // Clear out the transform, because it doesn't make sense absent a 851 // source buffer 852 error = hwcLayer->setTransform(HWC2::Transform::None); 853 if (error != HWC2::Error::None) { 854 ALOGE("[%s] Failed to clear transform: %s (%d)", mName.string(), 855 to_string(error).c_str(), static_cast<int32_t>(error)); 856 } 857 858 return; 859 } 860 861 // Device or Cursor layers 862 if (mPotentialCursor) { 863 ALOGV("[%s] Requesting Cursor composition", mName.string()); 864 setCompositionType(hwcId, HWC2::Composition::Cursor); 865 } else { 866 ALOGV("[%s] Requesting Device composition", mName.string()); 867 setCompositionType(hwcId, HWC2::Composition::Device); 868 } 869 870 ALOGV("setPerFrameData: dataspace = %d", mCurrentState.dataSpace); 871 error = hwcLayer->setDataspace(mCurrentState.dataSpace); 872 if (error != HWC2::Error::None) { 873 ALOGE("[%s] Failed to set dataspace %d: %s (%d)", mName.string(), 874 mCurrentState.dataSpace, to_string(error).c_str(), 875 static_cast<int32_t>(error)); 876 } 877 878 uint32_t hwcSlot = 0; 879 sp<GraphicBuffer> hwcBuffer; 880 hwcInfo.bufferCache.getHwcBuffer(mActiveBufferSlot, mActiveBuffer, 881 &hwcSlot, &hwcBuffer); 882 883 auto acquireFence = mSurfaceFlingerConsumer->getCurrentFence(); 884 error = hwcLayer->setBuffer(hwcSlot, hwcBuffer, acquireFence); 885 if (error != HWC2::Error::None) { 886 ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(), 887 mActiveBuffer->handle, to_string(error).c_str(), 888 static_cast<int32_t>(error)); 889 } 890} 891 892android_dataspace Layer::getDataSpace() const { 893 return mCurrentState.dataSpace; 894} 895#else 896void Layer::setPerFrameData(const sp<const DisplayDevice>& hw, 897 HWComposer::HWCLayerInterface& layer) { 898 // we have to set the visible region on every frame because 899 // we currently free it during onLayerDisplayed(), which is called 900 // after HWComposer::commit() -- every frame. 901 // Apply this display's projection's viewport to the visible region 902 // before giving it to the HWC HAL. 903 const Transform& tr = hw->getTransform(); 904 Region visible = tr.transform(visibleRegion.intersect(hw->getViewport())); 905 layer.setVisibleRegionScreen(visible); 906 layer.setSurfaceDamage(surfaceDamageRegion); 907 mIsGlesComposition = (layer.getCompositionType() == HWC_FRAMEBUFFER); 908 909 if (mSidebandStream.get()) { 910 layer.setSidebandStream(mSidebandStream); 911 } else { 912 // NOTE: buffer can be NULL if the client never drew into this 913 // layer yet, or if we ran out of memory 914 layer.setBuffer(mActiveBuffer); 915 } 916} 917#endif 918 919#ifdef USE_HWC2 920void Layer::updateCursorPosition(const sp<const DisplayDevice>& displayDevice) { 921 auto hwcId = displayDevice->getHwcDisplayId(); 922 if (mHwcLayers.count(hwcId) == 0 || 923 getCompositionType(hwcId) != HWC2::Composition::Cursor) { 924 return; 925 } 926 927 // This gives us only the "orientation" component of the transform 928 const State& s(getCurrentState()); 929 930 // Apply the layer's transform, followed by the display's global transform 931 // Here we're guaranteed that the layer's transform preserves rects 932 Rect win(s.active.w, s.active.h); 933 if (!s.crop.isEmpty()) { 934 win.intersect(s.crop, &win); 935 } 936 // Subtract the transparent region and snap to the bounds 937 Rect bounds = reduce(win, s.activeTransparentRegion); 938 Rect frame(getTransform().transform(bounds)); 939 frame.intersect(displayDevice->getViewport(), &frame); 940 if (!s.finalCrop.isEmpty()) { 941 frame.intersect(s.finalCrop, &frame); 942 } 943 auto& displayTransform(displayDevice->getTransform()); 944 auto position = displayTransform.transform(frame); 945 946 auto error = mHwcLayers[hwcId].layer->setCursorPosition(position.left, 947 position.top); 948 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set cursor position " 949 "to (%d, %d): %s (%d)", mName.string(), position.left, 950 position.top, to_string(error).c_str(), 951 static_cast<int32_t>(error)); 952} 953#else 954void Layer::setAcquireFence(const sp<const DisplayDevice>& /* hw */, 955 HWComposer::HWCLayerInterface& layer) { 956 int fenceFd = -1; 957 958 // TODO: there is a possible optimization here: we only need to set the 959 // acquire fence the first time a new buffer is acquired on EACH display. 960 961 if (layer.getCompositionType() == HWC_OVERLAY || layer.getCompositionType() == HWC_CURSOR_OVERLAY) { 962 sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence(); 963 if (fence->isValid()) { 964 fenceFd = fence->dup(); 965 if (fenceFd == -1) { 966 ALOGW("failed to dup layer fence, skipping sync: %d", errno); 967 } 968 } 969 } 970 layer.setAcquireFenceFd(fenceFd); 971} 972 973Rect Layer::getPosition( 974 const sp<const DisplayDevice>& hw) 975{ 976 // this gives us only the "orientation" component of the transform 977 const State& s(getCurrentState()); 978 979 // apply the layer's transform, followed by the display's global transform 980 // here we're guaranteed that the layer's transform preserves rects 981 Rect win(s.active.w, s.active.h); 982 if (!s.crop.isEmpty()) { 983 win.intersect(s.crop, &win); 984 } 985 // subtract the transparent region and snap to the bounds 986 Rect bounds = reduce(win, s.activeTransparentRegion); 987 Rect frame(getTransform().transform(bounds)); 988 frame.intersect(hw->getViewport(), &frame); 989 if (!s.finalCrop.isEmpty()) { 990 frame.intersect(s.finalCrop, &frame); 991 } 992 const Transform& tr(hw->getTransform()); 993 return Rect(tr.transform(frame)); 994} 995#endif 996 997// --------------------------------------------------------------------------- 998// drawing... 999// --------------------------------------------------------------------------- 1000 1001void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const { 1002 onDraw(hw, clip, false); 1003} 1004 1005void Layer::draw(const sp<const DisplayDevice>& hw, 1006 bool useIdentityTransform) const { 1007 onDraw(hw, Region(hw->bounds()), useIdentityTransform); 1008} 1009 1010void Layer::draw(const sp<const DisplayDevice>& hw) const { 1011 onDraw(hw, Region(hw->bounds()), false); 1012} 1013 1014static constexpr mat4 inverseOrientation(uint32_t transform) { 1015 const mat4 flipH(-1,0,0,0, 0,1,0,0, 0,0,1,0, 1,0,0,1); 1016 const mat4 flipV( 1,0,0,0, 0,-1,0,0, 0,0,1,0, 0,1,0,1); 1017 const mat4 rot90( 0,1,0,0, -1,0,0,0, 0,0,1,0, 1,0,0,1); 1018 mat4 tr; 1019 1020 if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 1021 tr = tr * rot90; 1022 } 1023 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H) { 1024 tr = tr * flipH; 1025 } 1026 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V) { 1027 tr = tr * flipV; 1028 } 1029 return inverse(tr); 1030} 1031 1032/* 1033 * onDraw will draw the current layer onto the presentable buffer 1034 */ 1035void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip, 1036 bool useIdentityTransform) const 1037{ 1038 ATRACE_CALL(); 1039 1040 if (CC_UNLIKELY(mActiveBuffer == 0)) { 1041 // the texture has not been created yet, this Layer has 1042 // in fact never been drawn into. This happens frequently with 1043 // SurfaceView because the WindowManager can't know when the client 1044 // has drawn the first time. 1045 1046 // If there is nothing under us, we paint the screen in black, otherwise 1047 // we just skip this update. 1048 1049 // figure out if there is something below us 1050 Region under; 1051 bool finished = false; 1052 mFlinger->mDrawingState.traverseInZOrder([&](Layer* layer) { 1053 if (finished || layer == static_cast<Layer const*>(this)) { 1054 finished = true; 1055 return; 1056 } 1057 under.orSelf( hw->getTransform().transform(layer->visibleRegion) ); 1058 }); 1059 // if not everything below us is covered, we plug the holes! 1060 Region holes(clip.subtract(under)); 1061 if (!holes.isEmpty()) { 1062 clearWithOpenGL(hw, 0, 0, 0, 1); 1063 } 1064 return; 1065 } 1066 1067 // Bind the current buffer to the GL texture, and wait for it to be 1068 // ready for us to draw into. 1069 status_t err = mSurfaceFlingerConsumer->bindTextureImage(); 1070 if (err != NO_ERROR) { 1071 ALOGW("onDraw: bindTextureImage failed (err=%d)", err); 1072 // Go ahead and draw the buffer anyway; no matter what we do the screen 1073 // is probably going to have something visibly wrong. 1074 } 1075 1076 bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure()); 1077 1078 RenderEngine& engine(mFlinger->getRenderEngine()); 1079 1080 if (!blackOutLayer) { 1081 // TODO: we could be more subtle with isFixedSize() 1082 const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize(); 1083 1084 // Query the texture matrix given our current filtering mode. 1085 float textureMatrix[16]; 1086 mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering); 1087 mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix); 1088 1089 if (getTransformToDisplayInverse()) { 1090 1091 /* 1092 * the code below applies the primary display's inverse transform to 1093 * the texture transform 1094 */ 1095 uint32_t transform = 1096 DisplayDevice::getPrimaryDisplayOrientationTransform(); 1097 mat4 tr = inverseOrientation(transform); 1098 1099 /** 1100 * TODO(b/36727915): This is basically a hack. 1101 * 1102 * Ensure that regardless of the parent transformation, 1103 * this buffer is always transformed from native display 1104 * orientation to display orientation. For example, in the case 1105 * of a camera where the buffer remains in native orientation, 1106 * we want the pixels to always be upright. 1107 */ 1108 if (getParent() != nullptr) { 1109 const auto parentTransform = getParent()->getTransform(); 1110 tr = tr * inverseOrientation(parentTransform.getOrientation()); 1111 } 1112 1113 // and finally apply it to the original texture matrix 1114 const mat4 texTransform(mat4(static_cast<const float*>(textureMatrix)) * tr); 1115 memcpy(textureMatrix, texTransform.asArray(), sizeof(textureMatrix)); 1116 } 1117 1118 // Set things up for texturing. 1119 mTexture.setDimensions(mActiveBuffer->getWidth(), mActiveBuffer->getHeight()); 1120 mTexture.setFiltering(useFiltering); 1121 mTexture.setMatrix(textureMatrix); 1122 1123 engine.setupLayerTexturing(mTexture); 1124 } else { 1125 engine.setupLayerBlackedOut(); 1126 } 1127 drawWithOpenGL(hw, useIdentityTransform); 1128 engine.disableTexturing(); 1129} 1130 1131 1132void Layer::clearWithOpenGL(const sp<const DisplayDevice>& hw, 1133 float red, float green, float blue, 1134 float alpha) const 1135{ 1136 RenderEngine& engine(mFlinger->getRenderEngine()); 1137 computeGeometry(hw, mMesh, false); 1138 engine.setupFillWithColor(red, green, blue, alpha); 1139 engine.drawMesh(mMesh); 1140} 1141 1142void Layer::clearWithOpenGL( 1143 const sp<const DisplayDevice>& hw) const { 1144 clearWithOpenGL(hw, 0,0,0,0); 1145} 1146 1147void Layer::drawWithOpenGL(const sp<const DisplayDevice>& hw, 1148 bool useIdentityTransform) const { 1149 const State& s(getDrawingState()); 1150 1151 computeGeometry(hw, mMesh, useIdentityTransform); 1152 1153 /* 1154 * NOTE: the way we compute the texture coordinates here produces 1155 * different results than when we take the HWC path -- in the later case 1156 * the "source crop" is rounded to texel boundaries. 1157 * This can produce significantly different results when the texture 1158 * is scaled by a large amount. 1159 * 1160 * The GL code below is more logical (imho), and the difference with 1161 * HWC is due to a limitation of the HWC API to integers -- a question 1162 * is suspend is whether we should ignore this problem or revert to 1163 * GL composition when a buffer scaling is applied (maybe with some 1164 * minimal value)? Or, we could make GL behave like HWC -- but this feel 1165 * like more of a hack. 1166 */ 1167 Rect win(computeBounds()); 1168 1169 Transform t = getTransform(); 1170 if (!s.finalCrop.isEmpty()) { 1171 win = t.transform(win); 1172 if (!win.intersect(s.finalCrop, &win)) { 1173 win.clear(); 1174 } 1175 win = t.inverse().transform(win); 1176 if (!win.intersect(computeBounds(), &win)) { 1177 win.clear(); 1178 } 1179 } 1180 1181 float left = float(win.left) / float(s.active.w); 1182 float top = float(win.top) / float(s.active.h); 1183 float right = float(win.right) / float(s.active.w); 1184 float bottom = float(win.bottom) / float(s.active.h); 1185 1186 // TODO: we probably want to generate the texture coords with the mesh 1187 // here we assume that we only have 4 vertices 1188 Mesh::VertexArray<vec2> texCoords(mMesh.getTexCoordArray<vec2>()); 1189 texCoords[0] = vec2(left, 1.0f - top); 1190 texCoords[1] = vec2(left, 1.0f - bottom); 1191 texCoords[2] = vec2(right, 1.0f - bottom); 1192 texCoords[3] = vec2(right, 1.0f - top); 1193 1194 RenderEngine& engine(mFlinger->getRenderEngine()); 1195 engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), getAlpha()); 1196#ifdef USE_HWC2 1197 engine.setSourceDataSpace(mCurrentState.dataSpace); 1198#endif 1199 engine.drawMesh(mMesh); 1200 engine.disableBlending(); 1201} 1202 1203#ifdef USE_HWC2 1204void Layer::setCompositionType(int32_t hwcId, HWC2::Composition type, 1205 bool callIntoHwc) { 1206 if (mHwcLayers.count(hwcId) == 0) { 1207 ALOGE("setCompositionType called without a valid HWC layer"); 1208 return; 1209 } 1210 auto& hwcInfo = mHwcLayers[hwcId]; 1211 auto& hwcLayer = hwcInfo.layer; 1212 ALOGV("setCompositionType(%" PRIx64 ", %s, %d)", hwcLayer->getId(), 1213 to_string(type).c_str(), static_cast<int>(callIntoHwc)); 1214 if (hwcInfo.compositionType != type) { 1215 ALOGV(" actually setting"); 1216 hwcInfo.compositionType = type; 1217 if (callIntoHwc) { 1218 auto error = hwcLayer->setCompositionType(type); 1219 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set " 1220 "composition type %s: %s (%d)", mName.string(), 1221 to_string(type).c_str(), to_string(error).c_str(), 1222 static_cast<int32_t>(error)); 1223 } 1224 } 1225} 1226 1227HWC2::Composition Layer::getCompositionType(int32_t hwcId) const { 1228 if (hwcId == DisplayDevice::DISPLAY_ID_INVALID) { 1229 // If we're querying the composition type for a display that does not 1230 // have a HWC counterpart, then it will always be Client 1231 return HWC2::Composition::Client; 1232 } 1233 if (mHwcLayers.count(hwcId) == 0) { 1234 ALOGE("getCompositionType called with an invalid HWC layer"); 1235 return HWC2::Composition::Invalid; 1236 } 1237 return mHwcLayers.at(hwcId).compositionType; 1238} 1239 1240void Layer::setClearClientTarget(int32_t hwcId, bool clear) { 1241 if (mHwcLayers.count(hwcId) == 0) { 1242 ALOGE("setClearClientTarget called without a valid HWC layer"); 1243 return; 1244 } 1245 mHwcLayers[hwcId].clearClientTarget = clear; 1246} 1247 1248bool Layer::getClearClientTarget(int32_t hwcId) const { 1249 if (mHwcLayers.count(hwcId) == 0) { 1250 ALOGE("getClearClientTarget called without a valid HWC layer"); 1251 return false; 1252 } 1253 return mHwcLayers.at(hwcId).clearClientTarget; 1254} 1255#endif 1256 1257uint32_t Layer::getProducerStickyTransform() const { 1258 int producerStickyTransform = 0; 1259 int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform); 1260 if (ret != OK) { 1261 ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__, 1262 strerror(-ret), ret); 1263 return 0; 1264 } 1265 return static_cast<uint32_t>(producerStickyTransform); 1266} 1267 1268bool Layer::latchUnsignaledBuffers() { 1269 static bool propertyLoaded = false; 1270 static bool latch = false; 1271 static std::mutex mutex; 1272 std::lock_guard<std::mutex> lock(mutex); 1273 if (!propertyLoaded) { 1274 char value[PROPERTY_VALUE_MAX] = {}; 1275 property_get("debug.sf.latch_unsignaled", value, "0"); 1276 latch = atoi(value); 1277 propertyLoaded = true; 1278 } 1279 return latch; 1280} 1281 1282uint64_t Layer::getHeadFrameNumber() const { 1283 Mutex::Autolock lock(mQueueItemLock); 1284 if (!mQueueItems.empty()) { 1285 return mQueueItems[0].mFrameNumber; 1286 } else { 1287 return mCurrentFrameNumber; 1288 } 1289} 1290 1291bool Layer::headFenceHasSignaled() const { 1292#ifdef USE_HWC2 1293 if (latchUnsignaledBuffers()) { 1294 return true; 1295 } 1296 1297 Mutex::Autolock lock(mQueueItemLock); 1298 if (mQueueItems.empty()) { 1299 return true; 1300 } 1301 if (mQueueItems[0].mIsDroppable) { 1302 // Even though this buffer's fence may not have signaled yet, it could 1303 // be replaced by another buffer before it has a chance to, which means 1304 // that it's possible to get into a situation where a buffer is never 1305 // able to be latched. To avoid this, grab this buffer anyway. 1306 return true; 1307 } 1308 return mQueueItems[0].mFence->getSignalTime() != INT64_MAX; 1309#else 1310 return true; 1311#endif 1312} 1313 1314bool Layer::addSyncPoint(const std::shared_ptr<SyncPoint>& point) { 1315 if (point->getFrameNumber() <= mCurrentFrameNumber) { 1316 // Don't bother with a SyncPoint, since we've already latched the 1317 // relevant frame 1318 return false; 1319 } 1320 1321 Mutex::Autolock lock(mLocalSyncPointMutex); 1322 mLocalSyncPoints.push_back(point); 1323 return true; 1324} 1325 1326void Layer::setFiltering(bool filtering) { 1327 mFiltering = filtering; 1328} 1329 1330bool Layer::getFiltering() const { 1331 return mFiltering; 1332} 1333 1334// As documented in libhardware header, formats in the range 1335// 0x100 - 0x1FF are specific to the HAL implementation, and 1336// are known to have no alpha channel 1337// TODO: move definition for device-specific range into 1338// hardware.h, instead of using hard-coded values here. 1339#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) 1340 1341bool Layer::getOpacityForFormat(uint32_t format) { 1342 if (HARDWARE_IS_DEVICE_FORMAT(format)) { 1343 return true; 1344 } 1345 switch (format) { 1346 case HAL_PIXEL_FORMAT_RGBA_8888: 1347 case HAL_PIXEL_FORMAT_BGRA_8888: 1348 case HAL_PIXEL_FORMAT_RGBA_FP16: 1349 case HAL_PIXEL_FORMAT_RGBA_1010102: 1350 return false; 1351 } 1352 // in all other case, we have no blending (also for unknown formats) 1353 return true; 1354} 1355 1356// ---------------------------------------------------------------------------- 1357// local state 1358// ---------------------------------------------------------------------------- 1359 1360static void boundPoint(vec2* point, const Rect& crop) { 1361 if (point->x < crop.left) { 1362 point->x = crop.left; 1363 } 1364 if (point->x > crop.right) { 1365 point->x = crop.right; 1366 } 1367 if (point->y < crop.top) { 1368 point->y = crop.top; 1369 } 1370 if (point->y > crop.bottom) { 1371 point->y = crop.bottom; 1372 } 1373} 1374 1375void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh, 1376 bool useIdentityTransform) const 1377{ 1378 const Layer::State& s(getDrawingState()); 1379 const Transform hwTransform(hw->getTransform()); 1380 const uint32_t hw_h = hw->getHeight(); 1381 Rect win = computeBounds(); 1382 1383 vec2 lt = vec2(win.left, win.top); 1384 vec2 lb = vec2(win.left, win.bottom); 1385 vec2 rb = vec2(win.right, win.bottom); 1386 vec2 rt = vec2(win.right, win.top); 1387 1388 Transform layerTransform = getTransform(); 1389 if (!useIdentityTransform) { 1390 lt = layerTransform.transform(lt); 1391 lb = layerTransform.transform(lb); 1392 rb = layerTransform.transform(rb); 1393 rt = layerTransform.transform(rt); 1394 } 1395 1396 if (!s.finalCrop.isEmpty()) { 1397 boundPoint(<, s.finalCrop); 1398 boundPoint(&lb, s.finalCrop); 1399 boundPoint(&rb, s.finalCrop); 1400 boundPoint(&rt, s.finalCrop); 1401 } 1402 1403 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>()); 1404 position[0] = hwTransform.transform(lt); 1405 position[1] = hwTransform.transform(lb); 1406 position[2] = hwTransform.transform(rb); 1407 position[3] = hwTransform.transform(rt); 1408 for (size_t i=0 ; i<4 ; i++) { 1409 position[i].y = hw_h - position[i].y; 1410 } 1411} 1412 1413bool Layer::isOpaque(const Layer::State& s) const 1414{ 1415 // if we don't have a buffer yet, we're translucent regardless of the 1416 // layer's opaque flag. 1417 if (mActiveBuffer == 0) { 1418 return false; 1419 } 1420 1421 // if the layer has the opaque flag, then we're always opaque, 1422 // otherwise we use the current buffer's format. 1423 return ((s.flags & layer_state_t::eLayerOpaque) != 0) || mCurrentOpacity; 1424} 1425 1426bool Layer::isSecure() const 1427{ 1428 const Layer::State& s(mDrawingState); 1429 return (s.flags & layer_state_t::eLayerSecure); 1430} 1431 1432bool Layer::isProtected() const 1433{ 1434 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 1435 return (activeBuffer != 0) && 1436 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 1437} 1438 1439bool Layer::isFixedSize() const { 1440 return getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1441} 1442 1443bool Layer::isCropped() const { 1444 return !mCurrentCrop.isEmpty(); 1445} 1446 1447bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const { 1448 return mNeedsFiltering || hw->needsFiltering(); 1449} 1450 1451void Layer::setVisibleRegion(const Region& visibleRegion) { 1452 // always called from main thread 1453 this->visibleRegion = visibleRegion; 1454} 1455 1456void Layer::setCoveredRegion(const Region& coveredRegion) { 1457 // always called from main thread 1458 this->coveredRegion = coveredRegion; 1459} 1460 1461void Layer::setVisibleNonTransparentRegion(const Region& 1462 setVisibleNonTransparentRegion) { 1463 // always called from main thread 1464 this->visibleNonTransparentRegion = setVisibleNonTransparentRegion; 1465} 1466 1467// ---------------------------------------------------------------------------- 1468// transaction 1469// ---------------------------------------------------------------------------- 1470 1471void Layer::pushPendingState() { 1472 if (!mCurrentState.modified) { 1473 return; 1474 } 1475 1476 // If this transaction is waiting on the receipt of a frame, generate a sync 1477 // point and send it to the remote layer. 1478 if (mCurrentState.barrierLayer != nullptr) { 1479 sp<Layer> barrierLayer = mCurrentState.barrierLayer.promote(); 1480 if (barrierLayer == nullptr) { 1481 ALOGE("[%s] Unable to promote barrier Layer.", mName.string()); 1482 // If we can't promote the layer we are intended to wait on, 1483 // then it is expired or otherwise invalid. Allow this transaction 1484 // to be applied as per normal (no synchronization). 1485 mCurrentState.barrierLayer = nullptr; 1486 } else { 1487 auto syncPoint = std::make_shared<SyncPoint>( 1488 mCurrentState.frameNumber); 1489 if (barrierLayer->addSyncPoint(syncPoint)) { 1490 mRemoteSyncPoints.push_back(std::move(syncPoint)); 1491 } else { 1492 // We already missed the frame we're supposed to synchronize 1493 // on, so go ahead and apply the state update 1494 mCurrentState.barrierLayer = nullptr; 1495 } 1496 } 1497 1498 // Wake us up to check if the frame has been received 1499 setTransactionFlags(eTransactionNeeded); 1500 mFlinger->setTransactionFlags(eTraversalNeeded); 1501 } 1502 mPendingStates.push_back(mCurrentState); 1503} 1504 1505void Layer::popPendingState(State* stateToCommit) { 1506 auto oldFlags = stateToCommit->flags; 1507 *stateToCommit = mPendingStates[0]; 1508 stateToCommit->flags = (oldFlags & ~stateToCommit->mask) | 1509 (stateToCommit->flags & stateToCommit->mask); 1510 1511 mPendingStates.removeAt(0); 1512} 1513 1514bool Layer::applyPendingStates(State* stateToCommit) { 1515 bool stateUpdateAvailable = false; 1516 while (!mPendingStates.empty()) { 1517 if (mPendingStates[0].barrierLayer != nullptr) { 1518 if (mRemoteSyncPoints.empty()) { 1519 // If we don't have a sync point for this, apply it anyway. It 1520 // will be visually wrong, but it should keep us from getting 1521 // into too much trouble. 1522 ALOGE("[%s] No local sync point found", mName.string()); 1523 popPendingState(stateToCommit); 1524 stateUpdateAvailable = true; 1525 continue; 1526 } 1527 1528 if (mRemoteSyncPoints.front()->getFrameNumber() != 1529 mPendingStates[0].frameNumber) { 1530 ALOGE("[%s] Unexpected sync point frame number found", 1531 mName.string()); 1532 1533 // Signal our end of the sync point and then dispose of it 1534 mRemoteSyncPoints.front()->setTransactionApplied(); 1535 mRemoteSyncPoints.pop_front(); 1536 continue; 1537 } 1538 1539 if (mRemoteSyncPoints.front()->frameIsAvailable()) { 1540 // Apply the state update 1541 popPendingState(stateToCommit); 1542 stateUpdateAvailable = true; 1543 1544 // Signal our end of the sync point and then dispose of it 1545 mRemoteSyncPoints.front()->setTransactionApplied(); 1546 mRemoteSyncPoints.pop_front(); 1547 } else { 1548 break; 1549 } 1550 } else { 1551 popPendingState(stateToCommit); 1552 stateUpdateAvailable = true; 1553 } 1554 } 1555 1556 // If we still have pending updates, wake SurfaceFlinger back up and point 1557 // it at this layer so we can process them 1558 if (!mPendingStates.empty()) { 1559 setTransactionFlags(eTransactionNeeded); 1560 mFlinger->setTransactionFlags(eTraversalNeeded); 1561 } 1562 1563 mCurrentState.modified = false; 1564 return stateUpdateAvailable; 1565} 1566 1567void Layer::notifyAvailableFrames() { 1568 auto headFrameNumber = getHeadFrameNumber(); 1569 bool headFenceSignaled = headFenceHasSignaled(); 1570 Mutex::Autolock lock(mLocalSyncPointMutex); 1571 for (auto& point : mLocalSyncPoints) { 1572 if (headFrameNumber >= point->getFrameNumber() && headFenceSignaled) { 1573 point->setFrameAvailable(); 1574 } 1575 } 1576} 1577 1578uint32_t Layer::doTransaction(uint32_t flags) { 1579 ATRACE_CALL(); 1580 1581 pushPendingState(); 1582 Layer::State c = getCurrentState(); 1583 if (!applyPendingStates(&c)) { 1584 return 0; 1585 } 1586 1587 const Layer::State& s(getDrawingState()); 1588 1589 const bool sizeChanged = (c.requested.w != s.requested.w) || 1590 (c.requested.h != s.requested.h); 1591 1592 if (sizeChanged) { 1593 // the size changed, we need to ask our client to request a new buffer 1594 ALOGD_IF(DEBUG_RESIZE, 1595 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 1596 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1597 " requested={ wh={%4u,%4u} }}\n" 1598 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1599 " requested={ wh={%4u,%4u} }}\n", 1600 this, getName().string(), mCurrentTransform, 1601 getEffectiveScalingMode(), 1602 c.active.w, c.active.h, 1603 c.crop.left, 1604 c.crop.top, 1605 c.crop.right, 1606 c.crop.bottom, 1607 c.crop.getWidth(), 1608 c.crop.getHeight(), 1609 c.requested.w, c.requested.h, 1610 s.active.w, s.active.h, 1611 s.crop.left, 1612 s.crop.top, 1613 s.crop.right, 1614 s.crop.bottom, 1615 s.crop.getWidth(), 1616 s.crop.getHeight(), 1617 s.requested.w, s.requested.h); 1618 1619 // record the new size, form this point on, when the client request 1620 // a buffer, it'll get the new size. 1621 mSurfaceFlingerConsumer->setDefaultBufferSize( 1622 c.requested.w, c.requested.h); 1623 } 1624 1625 const bool resizePending = (c.requested.w != c.active.w) || 1626 (c.requested.h != c.active.h); 1627 if (!isFixedSize()) { 1628 if (resizePending && mSidebandStream == NULL) { 1629 // don't let Layer::doTransaction update the drawing state 1630 // if we have a pending resize, unless we are in fixed-size mode. 1631 // the drawing state will be updated only once we receive a buffer 1632 // with the correct size. 1633 // 1634 // in particular, we want to make sure the clip (which is part 1635 // of the geometry state) is latched together with the size but is 1636 // latched immediately when no resizing is involved. 1637 // 1638 // If a sideband stream is attached, however, we want to skip this 1639 // optimization so that transactions aren't missed when a buffer 1640 // never arrives 1641 1642 flags |= eDontUpdateGeometryState; 1643 } 1644 } 1645 1646 // Here we apply various requested geometry states, depending on our 1647 // latching configuration. See Layer.h for a detailed discussion of 1648 // how geometry latching is controlled. 1649 if (!(flags & eDontUpdateGeometryState)) { 1650 Layer::State& editCurrentState(getCurrentState()); 1651 1652 // If mFreezeGeometryUpdates is true we are in the setGeometryAppliesWithResize 1653 // mode, which causes attributes which normally latch regardless of scaling mode, 1654 // to be delayed. We copy the requested state to the active state making sure 1655 // to respect these rules (again see Layer.h for a detailed discussion). 1656 // 1657 // There is an awkward asymmetry in the handling of the crop states in the position 1658 // states, as can be seen below. Largely this arises from position and transform 1659 // being stored in the same data structure while having different latching rules. 1660 // b/38182305 1661 // 1662 // Careful that "c" and editCurrentState may not begin as equivalent due to 1663 // applyPendingStates in the presence of deferred transactions. 1664 if (mFreezeGeometryUpdates) { 1665 float tx = c.active.transform.tx(); 1666 float ty = c.active.transform.ty(); 1667 c.active = c.requested; 1668 c.active.transform.set(tx, ty); 1669 editCurrentState.active = c.active; 1670 } else { 1671 editCurrentState.active = editCurrentState.requested; 1672 c.active = c.requested; 1673 } 1674 } 1675 1676 if (s.active != c.active) { 1677 // invalidate and recompute the visible regions if needed 1678 flags |= Layer::eVisibleRegion; 1679 } 1680 1681 if (c.sequence != s.sequence) { 1682 // invalidate and recompute the visible regions if needed 1683 flags |= eVisibleRegion; 1684 this->contentDirty = true; 1685 1686 // we may use linear filtering, if the matrix scales us 1687 const uint8_t type = c.active.transform.getType(); 1688 mNeedsFiltering = (!c.active.transform.preserveRects() || 1689 (type >= Transform::SCALE)); 1690 } 1691 1692 // If the layer is hidden, signal and clear out all local sync points so 1693 // that transactions for layers depending on this layer's frames becoming 1694 // visible are not blocked 1695 if (c.flags & layer_state_t::eLayerHidden) { 1696 clearSyncPoints(); 1697 } 1698 1699 // Commit the transaction 1700 commitTransaction(c); 1701 return flags; 1702} 1703 1704void Layer::commitTransaction(const State& stateToCommit) { 1705 mDrawingState = stateToCommit; 1706} 1707 1708uint32_t Layer::getTransactionFlags(uint32_t flags) { 1709 return android_atomic_and(~flags, &mTransactionFlags) & flags; 1710} 1711 1712uint32_t Layer::setTransactionFlags(uint32_t flags) { 1713 return android_atomic_or(flags, &mTransactionFlags); 1714} 1715 1716bool Layer::setPosition(float x, float y, bool immediate) { 1717 if (mCurrentState.requested.transform.tx() == x && mCurrentState.requested.transform.ty() == y) 1718 return false; 1719 mCurrentState.sequence++; 1720 1721 // We update the requested and active position simultaneously because 1722 // we want to apply the position portion of the transform matrix immediately, 1723 // but still delay scaling when resizing a SCALING_MODE_FREEZE layer. 1724 mCurrentState.requested.transform.set(x, y); 1725 if (immediate && !mFreezeGeometryUpdates) { 1726 // Here we directly update the active state 1727 // unlike other setters, because we store it within 1728 // the transform, but use different latching rules. 1729 // b/38182305 1730 mCurrentState.active.transform.set(x, y); 1731 } 1732 mFreezeGeometryUpdates = mFreezeGeometryUpdates || !immediate; 1733 1734 mCurrentState.modified = true; 1735 setTransactionFlags(eTransactionNeeded); 1736 return true; 1737} 1738 1739bool Layer::setChildLayer(const sp<Layer>& childLayer, int32_t z) { 1740 ssize_t idx = mCurrentChildren.indexOf(childLayer); 1741 if (idx < 0) { 1742 return false; 1743 } 1744 if (childLayer->setLayer(z)) { 1745 mCurrentChildren.removeAt(idx); 1746 mCurrentChildren.add(childLayer); 1747 } 1748 return true; 1749} 1750 1751bool Layer::setLayer(int32_t z) { 1752 if (mCurrentState.z == z) 1753 return false; 1754 mCurrentState.sequence++; 1755 mCurrentState.z = z; 1756 mCurrentState.modified = true; 1757 1758 // Discard all relative layering. 1759 if (mCurrentState.zOrderRelativeOf != nullptr) { 1760 sp<Layer> strongRelative = mCurrentState.zOrderRelativeOf.promote(); 1761 if (strongRelative != nullptr) { 1762 strongRelative->removeZOrderRelative(this); 1763 } 1764 mCurrentState.zOrderRelativeOf = nullptr; 1765 } 1766 setTransactionFlags(eTransactionNeeded); 1767 return true; 1768} 1769 1770void Layer::removeZOrderRelative(const wp<Layer>& relative) { 1771 mCurrentState.zOrderRelatives.remove(relative); 1772 mCurrentState.sequence++; 1773 mCurrentState.modified = true; 1774 setTransactionFlags(eTransactionNeeded); 1775} 1776 1777void Layer::addZOrderRelative(const wp<Layer>& relative) { 1778 mCurrentState.zOrderRelatives.add(relative); 1779 mCurrentState.modified = true; 1780 mCurrentState.sequence++; 1781 setTransactionFlags(eTransactionNeeded); 1782} 1783 1784bool Layer::setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t z) { 1785 sp<Handle> handle = static_cast<Handle*>(relativeToHandle.get()); 1786 if (handle == nullptr) { 1787 return false; 1788 } 1789 sp<Layer> relative = handle->owner.promote(); 1790 if (relative == nullptr) { 1791 return false; 1792 } 1793 1794 mCurrentState.sequence++; 1795 mCurrentState.modified = true; 1796 mCurrentState.z = z; 1797 1798 mCurrentState.zOrderRelativeOf = relative; 1799 relative->addZOrderRelative(this); 1800 1801 setTransactionFlags(eTransactionNeeded); 1802 1803 return true; 1804} 1805 1806bool Layer::setSize(uint32_t w, uint32_t h) { 1807 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 1808 return false; 1809 mCurrentState.requested.w = w; 1810 mCurrentState.requested.h = h; 1811 mCurrentState.modified = true; 1812 setTransactionFlags(eTransactionNeeded); 1813 return true; 1814} 1815#ifdef USE_HWC2 1816bool Layer::setAlpha(float alpha) { 1817#else 1818bool Layer::setAlpha(uint8_t alpha) { 1819#endif 1820 if (mCurrentState.alpha == alpha) 1821 return false; 1822 mCurrentState.sequence++; 1823 mCurrentState.alpha = alpha; 1824 mCurrentState.modified = true; 1825 setTransactionFlags(eTransactionNeeded); 1826 return true; 1827} 1828bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 1829 mCurrentState.sequence++; 1830 mCurrentState.requested.transform.set( 1831 matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy); 1832 mCurrentState.modified = true; 1833 setTransactionFlags(eTransactionNeeded); 1834 return true; 1835} 1836bool Layer::setTransparentRegionHint(const Region& transparent) { 1837 mCurrentState.requestedTransparentRegion = transparent; 1838 mCurrentState.modified = true; 1839 setTransactionFlags(eTransactionNeeded); 1840 return true; 1841} 1842bool Layer::setFlags(uint8_t flags, uint8_t mask) { 1843 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 1844 if (mCurrentState.flags == newFlags) 1845 return false; 1846 mCurrentState.sequence++; 1847 mCurrentState.flags = newFlags; 1848 mCurrentState.mask = mask; 1849 mCurrentState.modified = true; 1850 setTransactionFlags(eTransactionNeeded); 1851 return true; 1852} 1853 1854bool Layer::setCrop(const Rect& crop, bool immediate) { 1855 if (mCurrentState.requestedCrop == crop) 1856 return false; 1857 mCurrentState.sequence++; 1858 mCurrentState.requestedCrop = crop; 1859 if (immediate && !mFreezeGeometryUpdates) { 1860 mCurrentState.crop = crop; 1861 } 1862 mFreezeGeometryUpdates = mFreezeGeometryUpdates || !immediate; 1863 1864 mCurrentState.modified = true; 1865 setTransactionFlags(eTransactionNeeded); 1866 return true; 1867} 1868 1869bool Layer::setFinalCrop(const Rect& crop, bool immediate) { 1870 if (mCurrentState.requestedFinalCrop == crop) 1871 return false; 1872 mCurrentState.sequence++; 1873 mCurrentState.requestedFinalCrop = crop; 1874 if (immediate && !mFreezeGeometryUpdates) { 1875 mCurrentState.finalCrop = crop; 1876 } 1877 mFreezeGeometryUpdates = mFreezeGeometryUpdates || !immediate; 1878 1879 mCurrentState.modified = true; 1880 setTransactionFlags(eTransactionNeeded); 1881 return true; 1882} 1883 1884bool Layer::setOverrideScalingMode(int32_t scalingMode) { 1885 if (scalingMode == mOverrideScalingMode) 1886 return false; 1887 mOverrideScalingMode = scalingMode; 1888 setTransactionFlags(eTransactionNeeded); 1889 return true; 1890} 1891 1892void Layer::setInfo(uint32_t type, uint32_t appId) { 1893 mCurrentState.appId = appId; 1894 mCurrentState.type = type; 1895 mCurrentState.modified = true; 1896 setTransactionFlags(eTransactionNeeded); 1897} 1898 1899uint32_t Layer::getEffectiveScalingMode() const { 1900 if (mOverrideScalingMode >= 0) { 1901 return mOverrideScalingMode; 1902 } 1903 return mCurrentScalingMode; 1904} 1905 1906bool Layer::setLayerStack(uint32_t layerStack) { 1907 if (mCurrentState.layerStack == layerStack) 1908 return false; 1909 mCurrentState.sequence++; 1910 mCurrentState.layerStack = layerStack; 1911 mCurrentState.modified = true; 1912 setTransactionFlags(eTransactionNeeded); 1913 return true; 1914} 1915 1916bool Layer::setDataSpace(android_dataspace dataSpace) { 1917 if (mCurrentState.dataSpace == dataSpace) 1918 return false; 1919 mCurrentState.sequence++; 1920 mCurrentState.dataSpace = dataSpace; 1921 mCurrentState.modified = true; 1922 setTransactionFlags(eTransactionNeeded); 1923 return true; 1924} 1925 1926uint32_t Layer::getLayerStack() const { 1927 auto p = getParent(); 1928 if (p == nullptr) { 1929 return getDrawingState().layerStack; 1930 } 1931 return p->getLayerStack(); 1932} 1933 1934void Layer::deferTransactionUntil(const sp<Layer>& barrierLayer, 1935 uint64_t frameNumber) { 1936 mCurrentState.barrierLayer = barrierLayer; 1937 mCurrentState.frameNumber = frameNumber; 1938 // We don't set eTransactionNeeded, because just receiving a deferral 1939 // request without any other state updates shouldn't actually induce a delay 1940 mCurrentState.modified = true; 1941 pushPendingState(); 1942 mCurrentState.barrierLayer = nullptr; 1943 mCurrentState.frameNumber = 0; 1944 mCurrentState.modified = false; 1945 ALOGE("Deferred transaction"); 1946} 1947 1948void Layer::deferTransactionUntil(const sp<IBinder>& barrierHandle, 1949 uint64_t frameNumber) { 1950 sp<Handle> handle = static_cast<Handle*>(barrierHandle.get()); 1951 deferTransactionUntil(handle->owner.promote(), frameNumber); 1952} 1953 1954void Layer::useSurfaceDamage() { 1955 if (mFlinger->mForceFullDamage) { 1956 surfaceDamageRegion = Region::INVALID_REGION; 1957 } else { 1958 surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage(); 1959 } 1960} 1961 1962void Layer::useEmptyDamage() { 1963 surfaceDamageRegion.clear(); 1964} 1965 1966// ---------------------------------------------------------------------------- 1967// pageflip handling... 1968// ---------------------------------------------------------------------------- 1969 1970bool Layer::shouldPresentNow(const DispSync& dispSync) const { 1971 if (mSidebandStreamChanged || mAutoRefresh) { 1972 return true; 1973 } 1974 1975 Mutex::Autolock lock(mQueueItemLock); 1976 if (mQueueItems.empty()) { 1977 return false; 1978 } 1979 auto timestamp = mQueueItems[0].mTimestamp; 1980 nsecs_t expectedPresent = 1981 mSurfaceFlingerConsumer->computeExpectedPresent(dispSync); 1982 1983 // Ignore timestamps more than a second in the future 1984 bool isPlausible = timestamp < (expectedPresent + s2ns(1)); 1985 ALOGW_IF(!isPlausible, "[%s] Timestamp %" PRId64 " seems implausible " 1986 "relative to expectedPresent %" PRId64, mName.string(), timestamp, 1987 expectedPresent); 1988 1989 bool isDue = timestamp < expectedPresent; 1990 return isDue || !isPlausible; 1991} 1992 1993bool Layer::onPreComposition(nsecs_t refreshStartTime) { 1994 if (mBufferLatched) { 1995 Mutex::Autolock lock(mFrameEventHistoryMutex); 1996 mFrameEventHistory.addPreComposition(mCurrentFrameNumber, refreshStartTime); 1997 } 1998 mRefreshPending = false; 1999 return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh; 2000} 2001 2002bool Layer::onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence, 2003 const std::shared_ptr<FenceTime>& presentFence, 2004 const CompositorTiming& compositorTiming) { 2005 mAcquireTimeline.updateSignalTimes(); 2006 mReleaseTimeline.updateSignalTimes(); 2007 2008 // mFrameLatencyNeeded is true when a new frame was latched for the 2009 // composition. 2010 if (!mFrameLatencyNeeded) 2011 return false; 2012 2013 // Update mFrameEventHistory. 2014 { 2015 Mutex::Autolock lock(mFrameEventHistoryMutex); 2016 mFrameEventHistory.addPostComposition(mCurrentFrameNumber, 2017 glDoneFence, presentFence, compositorTiming); 2018 } 2019 2020 // Update mFrameTracker. 2021 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 2022 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 2023 2024 std::shared_ptr<FenceTime> frameReadyFence = 2025 mSurfaceFlingerConsumer->getCurrentFenceTime(); 2026 if (frameReadyFence->isValid()) { 2027 mFrameTracker.setFrameReadyFence(std::move(frameReadyFence)); 2028 } else { 2029 // There was no fence for this frame, so assume that it was ready 2030 // to be presented at the desired present time. 2031 mFrameTracker.setFrameReadyTime(desiredPresentTime); 2032 } 2033 2034 if (presentFence->isValid()) { 2035 mFrameTracker.setActualPresentFence( 2036 std::shared_ptr<FenceTime>(presentFence)); 2037 } else { 2038 // The HWC doesn't support present fences, so use the refresh 2039 // timestamp instead. 2040 mFrameTracker.setActualPresentTime( 2041 mFlinger->getHwComposer().getRefreshTimestamp( 2042 HWC_DISPLAY_PRIMARY)); 2043 } 2044 2045 mFrameTracker.advanceFrame(); 2046 mFrameLatencyNeeded = false; 2047 return true; 2048} 2049 2050#ifdef USE_HWC2 2051void Layer::releasePendingBuffer(nsecs_t dequeueReadyTime) { 2052 if (!mSurfaceFlingerConsumer->releasePendingBuffer()) { 2053 return; 2054 } 2055 2056 auto releaseFenceTime = std::make_shared<FenceTime>( 2057 mSurfaceFlingerConsumer->getPrevFinalReleaseFence()); 2058 mReleaseTimeline.push(releaseFenceTime); 2059 2060 Mutex::Autolock lock(mFrameEventHistoryMutex); 2061 if (mPreviousFrameNumber != 0) { 2062 mFrameEventHistory.addRelease(mPreviousFrameNumber, 2063 dequeueReadyTime, std::move(releaseFenceTime)); 2064 } 2065} 2066#endif 2067 2068bool Layer::isHiddenByPolicy() const { 2069 const Layer::State& s(mDrawingState); 2070 const auto& parent = getParent(); 2071 if (parent != nullptr && parent->isHiddenByPolicy()) { 2072 return true; 2073 } 2074 return s.flags & layer_state_t::eLayerHidden; 2075} 2076 2077bool Layer::isVisible() const { 2078#ifdef USE_HWC2 2079 return !(isHiddenByPolicy()) && getAlpha() > 0.0f 2080 && (mActiveBuffer != NULL || mSidebandStream != NULL); 2081#else 2082 return !(isHiddenByPolicy()) && getAlpha() 2083 && (mActiveBuffer != NULL || mSidebandStream != NULL); 2084#endif 2085} 2086 2087bool Layer::allTransactionsSignaled() { 2088 auto headFrameNumber = getHeadFrameNumber(); 2089 bool matchingFramesFound = false; 2090 bool allTransactionsApplied = true; 2091 Mutex::Autolock lock(mLocalSyncPointMutex); 2092 2093 for (auto& point : mLocalSyncPoints) { 2094 if (point->getFrameNumber() > headFrameNumber) { 2095 break; 2096 } 2097 matchingFramesFound = true; 2098 2099 if (!point->frameIsAvailable()) { 2100 // We haven't notified the remote layer that the frame for 2101 // this point is available yet. Notify it now, and then 2102 // abort this attempt to latch. 2103 point->setFrameAvailable(); 2104 allTransactionsApplied = false; 2105 break; 2106 } 2107 2108 allTransactionsApplied = allTransactionsApplied && point->transactionIsApplied(); 2109 } 2110 return !matchingFramesFound || allTransactionsApplied; 2111} 2112 2113Region Layer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime) 2114{ 2115 ATRACE_CALL(); 2116 2117 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { 2118 // mSidebandStreamChanged was true 2119 mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream(); 2120 if (mSidebandStream != NULL) { 2121 setTransactionFlags(eTransactionNeeded); 2122 mFlinger->setTransactionFlags(eTraversalNeeded); 2123 } 2124 recomputeVisibleRegions = true; 2125 2126 const State& s(getDrawingState()); 2127 return getTransform().transform(Region(Rect(s.active.w, s.active.h))); 2128 } 2129 2130 Region outDirtyRegion; 2131 if (mQueuedFrames <= 0 && !mAutoRefresh) { 2132 return outDirtyRegion; 2133 } 2134 2135 // if we've already called updateTexImage() without going through 2136 // a composition step, we have to skip this layer at this point 2137 // because we cannot call updateTeximage() without a corresponding 2138 // compositionComplete() call. 2139 // we'll trigger an update in onPreComposition(). 2140 if (mRefreshPending) { 2141 return outDirtyRegion; 2142 } 2143 2144 // If the head buffer's acquire fence hasn't signaled yet, return and 2145 // try again later 2146 if (!headFenceHasSignaled()) { 2147 mFlinger->signalLayerUpdate(); 2148 return outDirtyRegion; 2149 } 2150 2151 // Capture the old state of the layer for comparisons later 2152 const State& s(getDrawingState()); 2153 const bool oldOpacity = isOpaque(s); 2154 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 2155 2156 if (!allTransactionsSignaled()) { 2157 mFlinger->signalLayerUpdate(); 2158 return outDirtyRegion; 2159 } 2160 2161 // This boolean is used to make sure that SurfaceFlinger's shadow copy 2162 // of the buffer queue isn't modified when the buffer queue is returning 2163 // BufferItem's that weren't actually queued. This can happen in shared 2164 // buffer mode. 2165 bool queuedBuffer = false; 2166 LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 2167 getProducerStickyTransform() != 0, mName.string(), 2168 mOverrideScalingMode, mFreezeGeometryUpdates); 2169 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, 2170 mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer, 2171 mLastFrameNumberReceived); 2172 if (updateResult == BufferQueue::PRESENT_LATER) { 2173 // Producer doesn't want buffer to be displayed yet. Signal a 2174 // layer update so we check again at the next opportunity. 2175 mFlinger->signalLayerUpdate(); 2176 return outDirtyRegion; 2177 } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) { 2178 // If the buffer has been rejected, remove it from the shadow queue 2179 // and return early 2180 if (queuedBuffer) { 2181 Mutex::Autolock lock(mQueueItemLock); 2182 mQueueItems.removeAt(0); 2183 android_atomic_dec(&mQueuedFrames); 2184 } 2185 return outDirtyRegion; 2186 } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { 2187 // This can occur if something goes wrong when trying to create the 2188 // EGLImage for this buffer. If this happens, the buffer has already 2189 // been released, so we need to clean up the queue and bug out 2190 // early. 2191 if (queuedBuffer) { 2192 Mutex::Autolock lock(mQueueItemLock); 2193 mQueueItems.clear(); 2194 android_atomic_and(0, &mQueuedFrames); 2195 } 2196 2197 // Once we have hit this state, the shadow queue may no longer 2198 // correctly reflect the incoming BufferQueue's contents, so even if 2199 // updateTexImage starts working, the only safe course of action is 2200 // to continue to ignore updates. 2201 mUpdateTexImageFailed = true; 2202 2203 return outDirtyRegion; 2204 } 2205 2206 if (queuedBuffer) { 2207 // Autolock scope 2208 auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2209 2210 Mutex::Autolock lock(mQueueItemLock); 2211 2212 // Remove any stale buffers that have been dropped during 2213 // updateTexImage 2214 while (mQueueItems[0].mFrameNumber != currentFrameNumber) { 2215 mQueueItems.removeAt(0); 2216 android_atomic_dec(&mQueuedFrames); 2217 } 2218 2219 mQueueItems.removeAt(0); 2220 } 2221 2222 2223 // Decrement the queued-frames count. Signal another event if we 2224 // have more frames pending. 2225 if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) 2226 || mAutoRefresh) { 2227 mFlinger->signalLayerUpdate(); 2228 } 2229 2230 // update the active buffer 2231 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer( 2232 &mActiveBufferSlot); 2233 if (mActiveBuffer == NULL) { 2234 // this can only happen if the very first buffer was rejected. 2235 return outDirtyRegion; 2236 } 2237 2238 mBufferLatched = true; 2239 mPreviousFrameNumber = mCurrentFrameNumber; 2240 mCurrentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2241 2242 { 2243 Mutex::Autolock lock(mFrameEventHistoryMutex); 2244 mFrameEventHistory.addLatch(mCurrentFrameNumber, latchTime); 2245#ifndef USE_HWC2 2246 auto releaseFenceTime = std::make_shared<FenceTime>( 2247 mSurfaceFlingerConsumer->getPrevFinalReleaseFence()); 2248 mReleaseTimeline.push(releaseFenceTime); 2249 if (mPreviousFrameNumber != 0) { 2250 mFrameEventHistory.addRelease(mPreviousFrameNumber, 2251 latchTime, std::move(releaseFenceTime)); 2252 } 2253#endif 2254 } 2255 2256 mRefreshPending = true; 2257 mFrameLatencyNeeded = true; 2258 if (oldActiveBuffer == NULL) { 2259 // the first time we receive a buffer, we need to trigger a 2260 // geometry invalidation. 2261 recomputeVisibleRegions = true; 2262 } 2263 2264 setDataSpace(mSurfaceFlingerConsumer->getCurrentDataSpace()); 2265 2266 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 2267 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 2268 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 2269 if ((crop != mCurrentCrop) || 2270 (transform != mCurrentTransform) || 2271 (scalingMode != mCurrentScalingMode)) 2272 { 2273 mCurrentCrop = crop; 2274 mCurrentTransform = transform; 2275 mCurrentScalingMode = scalingMode; 2276 recomputeVisibleRegions = true; 2277 } 2278 2279 if (oldActiveBuffer != NULL) { 2280 uint32_t bufWidth = mActiveBuffer->getWidth(); 2281 uint32_t bufHeight = mActiveBuffer->getHeight(); 2282 if (bufWidth != uint32_t(oldActiveBuffer->width) || 2283 bufHeight != uint32_t(oldActiveBuffer->height)) { 2284 recomputeVisibleRegions = true; 2285 } 2286 } 2287 2288 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 2289 if (oldOpacity != isOpaque(s)) { 2290 recomputeVisibleRegions = true; 2291 } 2292 2293 // Remove any sync points corresponding to the buffer which was just 2294 // latched 2295 { 2296 Mutex::Autolock lock(mLocalSyncPointMutex); 2297 auto point = mLocalSyncPoints.begin(); 2298 while (point != mLocalSyncPoints.end()) { 2299 if (!(*point)->frameIsAvailable() || 2300 !(*point)->transactionIsApplied()) { 2301 // This sync point must have been added since we started 2302 // latching. Don't drop it yet. 2303 ++point; 2304 continue; 2305 } 2306 2307 if ((*point)->getFrameNumber() <= mCurrentFrameNumber) { 2308 point = mLocalSyncPoints.erase(point); 2309 } else { 2310 ++point; 2311 } 2312 } 2313 } 2314 2315 // FIXME: postedRegion should be dirty & bounds 2316 Region dirtyRegion(Rect(s.active.w, s.active.h)); 2317 2318 // transform the dirty region to window-manager space 2319 outDirtyRegion = (getTransform().transform(dirtyRegion)); 2320 2321 return outDirtyRegion; 2322} 2323 2324uint32_t Layer::getEffectiveUsage(uint32_t usage) const 2325{ 2326 // TODO: should we do something special if mSecure is set? 2327 if (mProtectedByApp) { 2328 // need a hardware-protected path to external video sink 2329 usage |= GraphicBuffer::USAGE_PROTECTED; 2330 } 2331 if (mPotentialCursor) { 2332 usage |= GraphicBuffer::USAGE_CURSOR; 2333 } 2334 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 2335 return usage; 2336} 2337 2338void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 2339 uint32_t orientation = 0; 2340 if (!mFlinger->mDebugDisableTransformHint) { 2341 // The transform hint is used to improve performance, but we can 2342 // only have a single transform hint, it cannot 2343 // apply to all displays. 2344 const Transform& planeTransform(hw->getTransform()); 2345 orientation = planeTransform.getOrientation(); 2346 if (orientation & Transform::ROT_INVALID) { 2347 orientation = 0; 2348 } 2349 } 2350 mSurfaceFlingerConsumer->setTransformHint(orientation); 2351} 2352 2353// ---------------------------------------------------------------------------- 2354// debugging 2355// ---------------------------------------------------------------------------- 2356 2357void Layer::dump(String8& result, Colorizer& colorizer) const 2358{ 2359 const Layer::State& s(getDrawingState()); 2360 2361 colorizer.colorize(result, Colorizer::GREEN); 2362 result.appendFormat( 2363 "+ %s %p (%s)\n", 2364 getTypeId(), this, getName().string()); 2365 colorizer.reset(result); 2366 2367 s.activeTransparentRegion.dump(result, "transparentRegion"); 2368 visibleRegion.dump(result, "visibleRegion"); 2369 surfaceDamageRegion.dump(result, "surfaceDamageRegion"); 2370 sp<Client> client(mClientRef.promote()); 2371 2372 result.appendFormat( " " 2373 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), " 2374 "crop=(%4d,%4d,%4d,%4d), finalCrop=(%4d,%4d,%4d,%4d), " 2375 "isOpaque=%1d, invalidate=%1d, " 2376#ifdef USE_HWC2 2377 "alpha=%.3f, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2378#else 2379 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2380#endif 2381 " client=%p\n", 2382 getLayerStack(), s.z, 2383 s.active.transform.tx(), s.active.transform.ty(), 2384 s.active.w, s.active.h, 2385 s.crop.left, s.crop.top, 2386 s.crop.right, s.crop.bottom, 2387 s.finalCrop.left, s.finalCrop.top, 2388 s.finalCrop.right, s.finalCrop.bottom, 2389 isOpaque(s), contentDirty, 2390 s.alpha, s.flags, 2391 s.active.transform[0][0], s.active.transform[0][1], 2392 s.active.transform[1][0], s.active.transform[1][1], 2393 client.get()); 2394 2395 sp<const GraphicBuffer> buf0(mActiveBuffer); 2396 uint32_t w0=0, h0=0, s0=0, f0=0; 2397 if (buf0 != 0) { 2398 w0 = buf0->getWidth(); 2399 h0 = buf0->getHeight(); 2400 s0 = buf0->getStride(); 2401 f0 = buf0->format; 2402 } 2403 result.appendFormat( 2404 " " 2405 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 2406 " queued-frames=%d, mRefreshPending=%d\n", 2407 mFormat, w0, h0, s0,f0, 2408 mQueuedFrames, mRefreshPending); 2409 2410 if (mSurfaceFlingerConsumer != 0) { 2411 mSurfaceFlingerConsumer->dumpState(result, " "); 2412 } 2413} 2414 2415#ifdef USE_HWC2 2416void Layer::miniDumpHeader(String8& result) { 2417 result.append("----------------------------------------"); 2418 result.append("---------------------------------------\n"); 2419 result.append(" Layer name\n"); 2420 result.append(" Z | "); 2421 result.append(" Comp Type | "); 2422 result.append(" Disp Frame (LTRB) | "); 2423 result.append(" Source Crop (LTRB)\n"); 2424 result.append("----------------------------------------"); 2425 result.append("---------------------------------------\n"); 2426} 2427 2428void Layer::miniDump(String8& result, int32_t hwcId) const { 2429 if (mHwcLayers.count(hwcId) == 0) { 2430 return; 2431 } 2432 2433 String8 name; 2434 if (mName.length() > 77) { 2435 std::string shortened; 2436 shortened.append(mName.string(), 36); 2437 shortened.append("[...]"); 2438 shortened.append(mName.string() + (mName.length() - 36), 36); 2439 name = shortened.c_str(); 2440 } else { 2441 name = mName; 2442 } 2443 2444 result.appendFormat(" %s\n", name.string()); 2445 2446 const Layer::State& layerState(getDrawingState()); 2447 const HWCInfo& hwcInfo = mHwcLayers.at(hwcId); 2448 result.appendFormat(" %10u | ", layerState.z); 2449 result.appendFormat("%10s | ", 2450 to_string(getCompositionType(hwcId)).c_str()); 2451 const Rect& frame = hwcInfo.displayFrame; 2452 result.appendFormat("%4d %4d %4d %4d | ", frame.left, frame.top, 2453 frame.right, frame.bottom); 2454 const FloatRect& crop = hwcInfo.sourceCrop; 2455 result.appendFormat("%6.1f %6.1f %6.1f %6.1f\n", crop.left, crop.top, 2456 crop.right, crop.bottom); 2457 2458 result.append("- - - - - - - - - - - - - - - - - - - - "); 2459 result.append("- - - - - - - - - - - - - - - - - - - -\n"); 2460} 2461#endif 2462 2463void Layer::dumpFrameStats(String8& result) const { 2464 mFrameTracker.dumpStats(result); 2465} 2466 2467void Layer::clearFrameStats() { 2468 mFrameTracker.clearStats(); 2469} 2470 2471void Layer::logFrameStats() { 2472 mFrameTracker.logAndResetStats(mName); 2473} 2474 2475void Layer::getFrameStats(FrameStats* outStats) const { 2476 mFrameTracker.getStats(outStats); 2477} 2478 2479void Layer::dumpFrameEvents(String8& result) { 2480 result.appendFormat("- Layer %s (%s, %p)\n", 2481 getName().string(), getTypeId(), this); 2482 Mutex::Autolock lock(mFrameEventHistoryMutex); 2483 mFrameEventHistory.checkFencesForCompletion(); 2484 mFrameEventHistory.dump(result); 2485} 2486 2487void Layer::onDisconnect() { 2488 Mutex::Autolock lock(mFrameEventHistoryMutex); 2489 mFrameEventHistory.onDisconnect(); 2490} 2491 2492void Layer::addAndGetFrameTimestamps(const NewFrameEventsEntry* newTimestamps, 2493 FrameEventHistoryDelta *outDelta) { 2494 Mutex::Autolock lock(mFrameEventHistoryMutex); 2495 if (newTimestamps) { 2496 mAcquireTimeline.push(newTimestamps->acquireFence); 2497 mFrameEventHistory.addQueue(*newTimestamps); 2498 } 2499 2500 if (outDelta) { 2501 mFrameEventHistory.getAndResetDelta(outDelta); 2502 } 2503} 2504 2505std::vector<OccupancyTracker::Segment> Layer::getOccupancyHistory( 2506 bool forceFlush) { 2507 std::vector<OccupancyTracker::Segment> history; 2508 status_t result = mSurfaceFlingerConsumer->getOccupancyHistory(forceFlush, 2509 &history); 2510 if (result != NO_ERROR) { 2511 ALOGW("[%s] Failed to obtain occupancy history (%d)", mName.string(), 2512 result); 2513 return {}; 2514 } 2515 return history; 2516} 2517 2518bool Layer::getTransformToDisplayInverse() const { 2519 return mSurfaceFlingerConsumer->getTransformToDisplayInverse(); 2520} 2521 2522void Layer::addChild(const sp<Layer>& layer) { 2523 mCurrentChildren.add(layer); 2524 layer->setParent(this); 2525} 2526 2527ssize_t Layer::removeChild(const sp<Layer>& layer) { 2528 layer->setParent(nullptr); 2529 return mCurrentChildren.remove(layer); 2530} 2531 2532bool Layer::reparentChildren(const sp<IBinder>& newParentHandle) { 2533 sp<Handle> handle = nullptr; 2534 sp<Layer> newParent = nullptr; 2535 if (newParentHandle == nullptr) { 2536 return false; 2537 } 2538 handle = static_cast<Handle*>(newParentHandle.get()); 2539 newParent = handle->owner.promote(); 2540 if (newParent == nullptr) { 2541 ALOGE("Unable to promote Layer handle"); 2542 return false; 2543 } 2544 2545 for (const sp<Layer>& child : mCurrentChildren) { 2546 // We don't call addChild as we need to delay updating the child's parent pointer until 2547 // a transaction occurs. Remember a refresh could occur in between now and the next 2548 // transaction, in which case the Layer's parent pointer would be updated, but changes 2549 // made to the parent in the same transaction would not have applied. 2550 // This means that the following kind of scenario wont work: 2551 // 2552 // 1. Existing and visible child and parent surface exist 2553 // 2. Create new surface hidden 2554 // 3. Open transaction 2555 // 4. Show the new surface, and reparent the old surface's children to it. 2556 // 5. Close transaction. 2557 // 2558 // If we were to update the parent pointer immediately, then the child surface 2559 // could disappear for one frame as it pointed at the new parent which 2560 // hasn't yet become visible as the transaction hasn't yet occurred. 2561 // 2562 // Instead we defer the reparenting to commitChildList which happens as part 2563 // of the global transaction. 2564 newParent->mCurrentChildren.add(child); 2565 2566 sp<Client> client(child->mClientRef.promote()); 2567 if (client != nullptr) { 2568 client->setParentLayer(newParent); 2569 } 2570 } 2571 mCurrentChildren.clear(); 2572 2573 return true; 2574} 2575 2576bool Layer::detachChildren() { 2577 traverseInZOrder(LayerVector::StateSet::Drawing, [this](Layer* child) { 2578 if (child == this) { 2579 return; 2580 } 2581 2582 sp<Client> client(child->mClientRef.promote()); 2583 if (client != nullptr) { 2584 client->detachLayer(child); 2585 } 2586 }); 2587 2588 return true; 2589} 2590 2591void Layer::setParent(const sp<Layer>& layer) { 2592 mParent = layer; 2593} 2594 2595void Layer::clearSyncPoints() { 2596 for (const auto& child : mCurrentChildren) { 2597 child->clearSyncPoints(); 2598 } 2599 2600 Mutex::Autolock lock(mLocalSyncPointMutex); 2601 for (auto& point : mLocalSyncPoints) { 2602 point->setFrameAvailable(); 2603 } 2604 mLocalSyncPoints.clear(); 2605} 2606 2607int32_t Layer::getZ() const { 2608 return mDrawingState.z; 2609} 2610 2611LayerVector Layer::makeTraversalList(LayerVector::StateSet stateSet) { 2612 LOG_ALWAYS_FATAL_IF(stateSet == LayerVector::StateSet::Invalid, 2613 "makeTraversalList received invalid stateSet"); 2614 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing; 2615 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren; 2616 const State& state = useDrawing ? mDrawingState : mCurrentState; 2617 2618 if (state.zOrderRelatives.size() == 0) { 2619 return children; 2620 } 2621 LayerVector traverse; 2622 2623 for (const wp<Layer>& weakRelative : state.zOrderRelatives) { 2624 sp<Layer> strongRelative = weakRelative.promote(); 2625 if (strongRelative != nullptr) { 2626 traverse.add(strongRelative); 2627 } 2628 } 2629 2630 for (const sp<Layer>& child : children) { 2631 traverse.add(child); 2632 } 2633 2634 return traverse; 2635} 2636 2637/** 2638 * Negatively signed relatives are before 'this' in Z-order. 2639 */ 2640void Layer::traverseInZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor) { 2641 LayerVector list = makeTraversalList(stateSet); 2642 2643 size_t i = 0; 2644 for (; i < list.size(); i++) { 2645 const auto& relative = list[i]; 2646 if (relative->getZ() >= 0) { 2647 break; 2648 } 2649 relative->traverseInZOrder(stateSet, visitor); 2650 } 2651 visitor(this); 2652 for (; i < list.size(); i++) { 2653 const auto& relative = list[i]; 2654 relative->traverseInZOrder(stateSet, visitor); 2655 } 2656} 2657 2658/** 2659 * Positively signed relatives are before 'this' in reverse Z-order. 2660 */ 2661void Layer::traverseInReverseZOrder(LayerVector::StateSet stateSet, 2662 const LayerVector::Visitor& visitor) { 2663 LayerVector list = makeTraversalList(stateSet); 2664 2665 int32_t i = 0; 2666 for (i = list.size()-1; i>=0; i--) { 2667 const auto& relative = list[i]; 2668 if (relative->getZ() < 0) { 2669 break; 2670 } 2671 relative->traverseInReverseZOrder(stateSet, visitor); 2672 } 2673 visitor(this); 2674 for (; i>=0; i--) { 2675 const auto& relative = list[i]; 2676 relative->traverseInReverseZOrder(stateSet, visitor); 2677 } 2678} 2679 2680Transform Layer::getTransform() const { 2681 Transform t; 2682 const auto& p = getParent(); 2683 if (p != nullptr) { 2684 t = p->getTransform(); 2685 2686 // If the parent is not using NATIVE_WINDOW_SCALING_MODE_FREEZE (e.g. 2687 // it isFixedSize) then there may be additional scaling not accounted 2688 // for in the transform. We need to mirror this scaling in child surfaces 2689 // or we will break the contract where WM can treat child surfaces as 2690 // pixels in the parent surface. 2691 if (p->isFixedSize()) { 2692 int bufferWidth; 2693 int bufferHeight; 2694 if ((p->mCurrentTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) == 0) { 2695 bufferWidth = p->mActiveBuffer->getWidth(); 2696 bufferHeight = p->mActiveBuffer->getHeight(); 2697 } else { 2698 bufferHeight = p->mActiveBuffer->getWidth(); 2699 bufferWidth = p->mActiveBuffer->getHeight(); 2700 } 2701 float sx = p->getDrawingState().active.w / 2702 static_cast<float>(bufferWidth); 2703 float sy = p->getDrawingState().active.h / 2704 static_cast<float>(bufferHeight); 2705 Transform extraParentScaling; 2706 extraParentScaling.set(sx, 0, 0, sy); 2707 t = t * extraParentScaling; 2708 } 2709 } 2710 return t * getDrawingState().active.transform; 2711} 2712 2713#ifdef USE_HWC2 2714float Layer::getAlpha() const { 2715 const auto& p = getParent(); 2716 2717 float parentAlpha = (p != nullptr) ? p->getAlpha() : 1.0; 2718 return parentAlpha * getDrawingState().alpha; 2719} 2720#else 2721uint8_t Layer::getAlpha() const { 2722 const auto& p = getParent(); 2723 2724 float parentAlpha = (p != nullptr) ? (p->getAlpha() / 255.0f) : 1.0; 2725 float drawingAlpha = getDrawingState().alpha / 255.0f; 2726 drawingAlpha = drawingAlpha * parentAlpha; 2727 return static_cast<uint8_t>(std::round(drawingAlpha * 255)); 2728} 2729#endif 2730 2731void Layer::commitChildList() { 2732 for (size_t i = 0; i < mCurrentChildren.size(); i++) { 2733 const auto& child = mCurrentChildren[i]; 2734 child->setParent(this); 2735 2736 child->commitChildList(); 2737 } 2738 mDrawingChildren = mCurrentChildren; 2739} 2740 2741// --------------------------------------------------------------------------- 2742 2743}; // namespace android 2744 2745#if defined(__gl_h_) 2746#error "don't include gl/gl.h in this file" 2747#endif 2748 2749#if defined(__gl2_h_) 2750#error "don't include gl2/gl2.h in this file" 2751#endif 2752