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