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