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