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