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