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