Layer.cpp revision 0ed70ddebe2a392c32b010e00229b9f0e2fd2e09
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 case HAL_PIXEL_FORMAT_RGBA_1010102: 1309 return false; 1310 } 1311 // in all other case, we have no blending (also for unknown formats) 1312 return true; 1313} 1314 1315// ---------------------------------------------------------------------------- 1316// local state 1317// ---------------------------------------------------------------------------- 1318 1319static void boundPoint(vec2* point, const Rect& crop) { 1320 if (point->x < crop.left) { 1321 point->x = crop.left; 1322 } 1323 if (point->x > crop.right) { 1324 point->x = crop.right; 1325 } 1326 if (point->y < crop.top) { 1327 point->y = crop.top; 1328 } 1329 if (point->y > crop.bottom) { 1330 point->y = crop.bottom; 1331 } 1332} 1333 1334void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh, 1335 bool useIdentityTransform) const 1336{ 1337 const Layer::State& s(getDrawingState()); 1338 const Transform hwTransform(hw->getTransform()); 1339 const uint32_t hw_h = hw->getHeight(); 1340 Rect win = computeBounds(); 1341 1342 vec2 lt = vec2(win.left, win.top); 1343 vec2 lb = vec2(win.left, win.bottom); 1344 vec2 rb = vec2(win.right, win.bottom); 1345 vec2 rt = vec2(win.right, win.top); 1346 1347 Transform layerTransform = getTransform(); 1348 if (!useIdentityTransform) { 1349 lt = layerTransform.transform(lt); 1350 lb = layerTransform.transform(lb); 1351 rb = layerTransform.transform(rb); 1352 rt = layerTransform.transform(rt); 1353 } 1354 1355 if (!s.finalCrop.isEmpty()) { 1356 boundPoint(<, s.finalCrop); 1357 boundPoint(&lb, s.finalCrop); 1358 boundPoint(&rb, s.finalCrop); 1359 boundPoint(&rt, s.finalCrop); 1360 } 1361 1362 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>()); 1363 position[0] = hwTransform.transform(lt); 1364 position[1] = hwTransform.transform(lb); 1365 position[2] = hwTransform.transform(rb); 1366 position[3] = hwTransform.transform(rt); 1367 for (size_t i=0 ; i<4 ; i++) { 1368 position[i].y = hw_h - position[i].y; 1369 } 1370} 1371 1372bool Layer::isOpaque(const Layer::State& s) const 1373{ 1374 // if we don't have a buffer yet, we're translucent regardless of the 1375 // layer's opaque flag. 1376 if (mActiveBuffer == 0) { 1377 return false; 1378 } 1379 1380 // if the layer has the opaque flag, then we're always opaque, 1381 // otherwise we use the current buffer's format. 1382 return ((s.flags & layer_state_t::eLayerOpaque) != 0) || mCurrentOpacity; 1383} 1384 1385bool Layer::isSecure() const 1386{ 1387 const Layer::State& s(mDrawingState); 1388 return (s.flags & layer_state_t::eLayerSecure); 1389} 1390 1391bool Layer::isProtected() const 1392{ 1393 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 1394 return (activeBuffer != 0) && 1395 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 1396} 1397 1398bool Layer::isFixedSize() const { 1399 return getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1400} 1401 1402bool Layer::isCropped() const { 1403 return !mCurrentCrop.isEmpty(); 1404} 1405 1406bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const { 1407 return mNeedsFiltering || hw->needsFiltering(); 1408} 1409 1410void Layer::setVisibleRegion(const Region& visibleRegion) { 1411 // always called from main thread 1412 this->visibleRegion = visibleRegion; 1413} 1414 1415void Layer::setCoveredRegion(const Region& coveredRegion) { 1416 // always called from main thread 1417 this->coveredRegion = coveredRegion; 1418} 1419 1420void Layer::setVisibleNonTransparentRegion(const Region& 1421 setVisibleNonTransparentRegion) { 1422 // always called from main thread 1423 this->visibleNonTransparentRegion = setVisibleNonTransparentRegion; 1424} 1425 1426// ---------------------------------------------------------------------------- 1427// transaction 1428// ---------------------------------------------------------------------------- 1429 1430void Layer::pushPendingState() { 1431 if (!mCurrentState.modified) { 1432 return; 1433 } 1434 1435 // If this transaction is waiting on the receipt of a frame, generate a sync 1436 // point and send it to the remote layer. 1437 if (mCurrentState.handle != nullptr) { 1438 sp<IBinder> strongBinder = mCurrentState.handle.promote(); 1439 sp<Handle> handle = nullptr; 1440 sp<Layer> handleLayer = nullptr; 1441 if (strongBinder != nullptr) { 1442 handle = static_cast<Handle*>(strongBinder.get()); 1443 handleLayer = handle->owner.promote(); 1444 } 1445 if (strongBinder == nullptr || handleLayer == nullptr) { 1446 ALOGE("[%s] Unable to promote Layer handle", mName.string()); 1447 // If we can't promote the layer we are intended to wait on, 1448 // then it is expired or otherwise invalid. Allow this transaction 1449 // to be applied as per normal (no synchronization). 1450 mCurrentState.handle = nullptr; 1451 } else { 1452 auto syncPoint = std::make_shared<SyncPoint>( 1453 mCurrentState.frameNumber); 1454 if (handleLayer->addSyncPoint(syncPoint)) { 1455 mRemoteSyncPoints.push_back(std::move(syncPoint)); 1456 } else { 1457 // We already missed the frame we're supposed to synchronize 1458 // on, so go ahead and apply the state update 1459 mCurrentState.handle = nullptr; 1460 } 1461 } 1462 1463 // Wake us up to check if the frame has been received 1464 setTransactionFlags(eTransactionNeeded); 1465 mFlinger->setTransactionFlags(eTraversalNeeded); 1466 } 1467 mPendingStates.push_back(mCurrentState); 1468} 1469 1470void Layer::popPendingState(State* stateToCommit) { 1471 auto oldFlags = stateToCommit->flags; 1472 *stateToCommit = mPendingStates[0]; 1473 stateToCommit->flags = (oldFlags & ~stateToCommit->mask) | 1474 (stateToCommit->flags & stateToCommit->mask); 1475 1476 mPendingStates.removeAt(0); 1477} 1478 1479bool Layer::applyPendingStates(State* stateToCommit) { 1480 bool stateUpdateAvailable = false; 1481 while (!mPendingStates.empty()) { 1482 if (mPendingStates[0].handle != nullptr) { 1483 if (mRemoteSyncPoints.empty()) { 1484 // If we don't have a sync point for this, apply it anyway. It 1485 // will be visually wrong, but it should keep us from getting 1486 // into too much trouble. 1487 ALOGE("[%s] No local sync point found", mName.string()); 1488 popPendingState(stateToCommit); 1489 stateUpdateAvailable = true; 1490 continue; 1491 } 1492 1493 if (mRemoteSyncPoints.front()->getFrameNumber() != 1494 mPendingStates[0].frameNumber) { 1495 ALOGE("[%s] Unexpected sync point frame number found", 1496 mName.string()); 1497 1498 // Signal our end of the sync point and then dispose of it 1499 mRemoteSyncPoints.front()->setTransactionApplied(); 1500 mRemoteSyncPoints.pop_front(); 1501 continue; 1502 } 1503 1504 if (mRemoteSyncPoints.front()->frameIsAvailable()) { 1505 // Apply the state update 1506 popPendingState(stateToCommit); 1507 stateUpdateAvailable = true; 1508 1509 // Signal our end of the sync point and then dispose of it 1510 mRemoteSyncPoints.front()->setTransactionApplied(); 1511 mRemoteSyncPoints.pop_front(); 1512 } else { 1513 break; 1514 } 1515 } else { 1516 popPendingState(stateToCommit); 1517 stateUpdateAvailable = true; 1518 } 1519 } 1520 1521 // If we still have pending updates, wake SurfaceFlinger back up and point 1522 // it at this layer so we can process them 1523 if (!mPendingStates.empty()) { 1524 setTransactionFlags(eTransactionNeeded); 1525 mFlinger->setTransactionFlags(eTraversalNeeded); 1526 } 1527 1528 mCurrentState.modified = false; 1529 return stateUpdateAvailable; 1530} 1531 1532void Layer::notifyAvailableFrames() { 1533 auto headFrameNumber = getHeadFrameNumber(); 1534 bool headFenceSignaled = headFenceHasSignaled(); 1535 Mutex::Autolock lock(mLocalSyncPointMutex); 1536 for (auto& point : mLocalSyncPoints) { 1537 if (headFrameNumber >= point->getFrameNumber() && headFenceSignaled) { 1538 point->setFrameAvailable(); 1539 } 1540 } 1541} 1542 1543uint32_t Layer::doTransaction(uint32_t flags) { 1544 ATRACE_CALL(); 1545 1546 pushPendingState(); 1547 Layer::State c = getCurrentState(); 1548 if (!applyPendingStates(&c)) { 1549 return 0; 1550 } 1551 1552 const Layer::State& s(getDrawingState()); 1553 1554 const bool sizeChanged = (c.requested.w != s.requested.w) || 1555 (c.requested.h != s.requested.h); 1556 1557 if (sizeChanged) { 1558 // the size changed, we need to ask our client to request a new buffer 1559 ALOGD_IF(DEBUG_RESIZE, 1560 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 1561 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1562 " requested={ wh={%4u,%4u} }}\n" 1563 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1564 " requested={ wh={%4u,%4u} }}\n", 1565 this, getName().string(), mCurrentTransform, 1566 getEffectiveScalingMode(), 1567 c.active.w, c.active.h, 1568 c.crop.left, 1569 c.crop.top, 1570 c.crop.right, 1571 c.crop.bottom, 1572 c.crop.getWidth(), 1573 c.crop.getHeight(), 1574 c.requested.w, c.requested.h, 1575 s.active.w, s.active.h, 1576 s.crop.left, 1577 s.crop.top, 1578 s.crop.right, 1579 s.crop.bottom, 1580 s.crop.getWidth(), 1581 s.crop.getHeight(), 1582 s.requested.w, s.requested.h); 1583 1584 // record the new size, form this point on, when the client request 1585 // a buffer, it'll get the new size. 1586 mSurfaceFlingerConsumer->setDefaultBufferSize( 1587 c.requested.w, c.requested.h); 1588 } 1589 1590 const bool resizePending = (c.requested.w != c.active.w) || 1591 (c.requested.h != c.active.h); 1592 if (!isFixedSize()) { 1593 if (resizePending && mSidebandStream == NULL) { 1594 // don't let Layer::doTransaction update the drawing state 1595 // if we have a pending resize, unless we are in fixed-size mode. 1596 // the drawing state will be updated only once we receive a buffer 1597 // with the correct size. 1598 // 1599 // in particular, we want to make sure the clip (which is part 1600 // of the geometry state) is latched together with the size but is 1601 // latched immediately when no resizing is involved. 1602 // 1603 // If a sideband stream is attached, however, we want to skip this 1604 // optimization so that transactions aren't missed when a buffer 1605 // never arrives 1606 1607 flags |= eDontUpdateGeometryState; 1608 } 1609 } 1610 1611 // always set active to requested, unless we're asked not to 1612 // this is used by Layer, which special cases resizes. 1613 if (flags & eDontUpdateGeometryState) { 1614 } else { 1615 Layer::State& editCurrentState(getCurrentState()); 1616 if (mFreezePositionUpdates) { 1617 float tx = c.active.transform.tx(); 1618 float ty = c.active.transform.ty(); 1619 c.active = c.requested; 1620 c.active.transform.set(tx, ty); 1621 editCurrentState.active = c.active; 1622 } else { 1623 editCurrentState.active = editCurrentState.requested; 1624 c.active = c.requested; 1625 } 1626 } 1627 1628 if (s.active != c.active) { 1629 // invalidate and recompute the visible regions if needed 1630 flags |= Layer::eVisibleRegion; 1631 } 1632 1633 if (c.sequence != s.sequence) { 1634 // invalidate and recompute the visible regions if needed 1635 flags |= eVisibleRegion; 1636 this->contentDirty = true; 1637 1638 // we may use linear filtering, if the matrix scales us 1639 const uint8_t type = c.active.transform.getType(); 1640 mNeedsFiltering = (!c.active.transform.preserveRects() || 1641 (type >= Transform::SCALE)); 1642 } 1643 1644 // If the layer is hidden, signal and clear out all local sync points so 1645 // that transactions for layers depending on this layer's frames becoming 1646 // visible are not blocked 1647 if (c.flags & layer_state_t::eLayerHidden) { 1648 clearSyncPoints(); 1649 } 1650 1651 // Commit the transaction 1652 commitTransaction(c); 1653 return flags; 1654} 1655 1656void Layer::commitTransaction(const State& stateToCommit) { 1657 mDrawingState = stateToCommit; 1658} 1659 1660uint32_t Layer::getTransactionFlags(uint32_t flags) { 1661 return android_atomic_and(~flags, &mTransactionFlags) & flags; 1662} 1663 1664uint32_t Layer::setTransactionFlags(uint32_t flags) { 1665 return android_atomic_or(flags, &mTransactionFlags); 1666} 1667 1668bool Layer::setPosition(float x, float y, bool immediate) { 1669 if (mCurrentState.requested.transform.tx() == x && mCurrentState.requested.transform.ty() == y) 1670 return false; 1671 mCurrentState.sequence++; 1672 1673 // We update the requested and active position simultaneously because 1674 // we want to apply the position portion of the transform matrix immediately, 1675 // but still delay scaling when resizing a SCALING_MODE_FREEZE layer. 1676 mCurrentState.requested.transform.set(x, y); 1677 if (immediate && !mFreezePositionUpdates) { 1678 mCurrentState.active.transform.set(x, y); 1679 } 1680 mFreezePositionUpdates = mFreezePositionUpdates || !immediate; 1681 1682 mCurrentState.modified = true; 1683 setTransactionFlags(eTransactionNeeded); 1684 return true; 1685} 1686 1687bool Layer::setChildLayer(const sp<Layer>& childLayer, int32_t z) { 1688 ssize_t idx = mCurrentChildren.indexOf(childLayer); 1689 if (idx < 0) { 1690 return false; 1691 } 1692 if (childLayer->setLayer(z)) { 1693 mCurrentChildren.removeAt(idx); 1694 mCurrentChildren.add(childLayer); 1695 } 1696 return true; 1697} 1698 1699bool Layer::setLayer(int32_t z) { 1700 if (mCurrentState.z == z) 1701 return false; 1702 mCurrentState.sequence++; 1703 mCurrentState.z = z; 1704 mCurrentState.modified = true; 1705 setTransactionFlags(eTransactionNeeded); 1706 return true; 1707} 1708 1709bool Layer::setSize(uint32_t w, uint32_t h) { 1710 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 1711 return false; 1712 mCurrentState.requested.w = w; 1713 mCurrentState.requested.h = h; 1714 mCurrentState.modified = true; 1715 setTransactionFlags(eTransactionNeeded); 1716 return true; 1717} 1718#ifdef USE_HWC2 1719bool Layer::setAlpha(float alpha) { 1720#else 1721bool Layer::setAlpha(uint8_t alpha) { 1722#endif 1723 if (mCurrentState.alpha == alpha) 1724 return false; 1725 mCurrentState.sequence++; 1726 mCurrentState.alpha = alpha; 1727 mCurrentState.modified = true; 1728 setTransactionFlags(eTransactionNeeded); 1729 return true; 1730} 1731bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 1732 mCurrentState.sequence++; 1733 mCurrentState.requested.transform.set( 1734 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); 1735 mCurrentState.modified = true; 1736 setTransactionFlags(eTransactionNeeded); 1737 return true; 1738} 1739bool Layer::setTransparentRegionHint(const Region& transparent) { 1740 mCurrentState.requestedTransparentRegion = transparent; 1741 mCurrentState.modified = true; 1742 setTransactionFlags(eTransactionNeeded); 1743 return true; 1744} 1745bool Layer::setFlags(uint8_t flags, uint8_t mask) { 1746 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 1747 if (mCurrentState.flags == newFlags) 1748 return false; 1749 mCurrentState.sequence++; 1750 mCurrentState.flags = newFlags; 1751 mCurrentState.mask = mask; 1752 mCurrentState.modified = true; 1753 setTransactionFlags(eTransactionNeeded); 1754 return true; 1755} 1756 1757bool Layer::setCrop(const Rect& crop, bool immediate) { 1758 if (mCurrentState.crop == crop) 1759 return false; 1760 mCurrentState.sequence++; 1761 mCurrentState.requestedCrop = crop; 1762 if (immediate) { 1763 mCurrentState.crop = crop; 1764 } 1765 mCurrentState.modified = true; 1766 setTransactionFlags(eTransactionNeeded); 1767 return true; 1768} 1769bool Layer::setFinalCrop(const Rect& crop) { 1770 if (mCurrentState.finalCrop == crop) 1771 return false; 1772 mCurrentState.sequence++; 1773 mCurrentState.finalCrop = crop; 1774 mCurrentState.modified = true; 1775 setTransactionFlags(eTransactionNeeded); 1776 return true; 1777} 1778 1779bool Layer::setOverrideScalingMode(int32_t scalingMode) { 1780 if (scalingMode == mOverrideScalingMode) 1781 return false; 1782 mOverrideScalingMode = scalingMode; 1783 setTransactionFlags(eTransactionNeeded); 1784 return true; 1785} 1786 1787void Layer::setInfo(uint32_t type, uint32_t appId) { 1788 mCurrentState.appId = appId; 1789 mCurrentState.type = type; 1790 mCurrentState.modified = true; 1791 setTransactionFlags(eTransactionNeeded); 1792} 1793 1794uint32_t Layer::getEffectiveScalingMode() const { 1795 if (mOverrideScalingMode >= 0) { 1796 return mOverrideScalingMode; 1797 } 1798 return mCurrentScalingMode; 1799} 1800 1801bool Layer::setLayerStack(uint32_t layerStack) { 1802 if (mCurrentState.layerStack == layerStack) 1803 return false; 1804 mCurrentState.sequence++; 1805 mCurrentState.layerStack = layerStack; 1806 mCurrentState.modified = true; 1807 setTransactionFlags(eTransactionNeeded); 1808 return true; 1809} 1810 1811bool Layer::setDataSpace(android_dataspace dataSpace) { 1812 if (mCurrentState.dataSpace == dataSpace) 1813 return false; 1814 mCurrentState.sequence++; 1815 mCurrentState.dataSpace = dataSpace; 1816 mCurrentState.modified = true; 1817 setTransactionFlags(eTransactionNeeded); 1818 return true; 1819} 1820 1821uint32_t Layer::getLayerStack() const { 1822 auto p = getParent(); 1823 if (p == nullptr) { 1824 return getDrawingState().layerStack; 1825 } 1826 return p->getLayerStack(); 1827} 1828 1829void Layer::deferTransactionUntil(const sp<IBinder>& handle, 1830 uint64_t frameNumber) { 1831 mCurrentState.handle = handle; 1832 mCurrentState.frameNumber = frameNumber; 1833 // We don't set eTransactionNeeded, because just receiving a deferral 1834 // request without any other state updates shouldn't actually induce a delay 1835 mCurrentState.modified = true; 1836 pushPendingState(); 1837 mCurrentState.handle = nullptr; 1838 mCurrentState.frameNumber = 0; 1839 mCurrentState.modified = false; 1840} 1841 1842void Layer::useSurfaceDamage() { 1843 if (mFlinger->mForceFullDamage) { 1844 surfaceDamageRegion = Region::INVALID_REGION; 1845 } else { 1846 surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage(); 1847 } 1848} 1849 1850void Layer::useEmptyDamage() { 1851 surfaceDamageRegion.clear(); 1852} 1853 1854// ---------------------------------------------------------------------------- 1855// pageflip handling... 1856// ---------------------------------------------------------------------------- 1857 1858bool Layer::shouldPresentNow(const DispSync& dispSync) const { 1859 if (mSidebandStreamChanged || mAutoRefresh) { 1860 return true; 1861 } 1862 1863 Mutex::Autolock lock(mQueueItemLock); 1864 if (mQueueItems.empty()) { 1865 return false; 1866 } 1867 auto timestamp = mQueueItems[0].mTimestamp; 1868 nsecs_t expectedPresent = 1869 mSurfaceFlingerConsumer->computeExpectedPresent(dispSync); 1870 1871 // Ignore timestamps more than a second in the future 1872 bool isPlausible = timestamp < (expectedPresent + s2ns(1)); 1873 ALOGW_IF(!isPlausible, "[%s] Timestamp %" PRId64 " seems implausible " 1874 "relative to expectedPresent %" PRId64, mName.string(), timestamp, 1875 expectedPresent); 1876 1877 bool isDue = timestamp < expectedPresent; 1878 return isDue || !isPlausible; 1879} 1880 1881bool Layer::onPreComposition(nsecs_t refreshStartTime) { 1882 if (mBufferLatched) { 1883 Mutex::Autolock lock(mFrameEventHistoryMutex); 1884 mFrameEventHistory.addPreComposition(mCurrentFrameNumber, refreshStartTime); 1885 } 1886 mRefreshPending = false; 1887 return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh; 1888} 1889 1890bool Layer::onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence, 1891 const std::shared_ptr<FenceTime>& presentFence, 1892 const std::shared_ptr<FenceTime>& retireFence, 1893 const CompositorTiming& compositorTiming) { 1894 mAcquireTimeline.updateSignalTimes(); 1895 mReleaseTimeline.updateSignalTimes(); 1896 1897 // mFrameLatencyNeeded is true when a new frame was latched for the 1898 // composition. 1899 if (!mFrameLatencyNeeded) 1900 return false; 1901 1902 // Update mFrameEventHistory. 1903 { 1904 Mutex::Autolock lock(mFrameEventHistoryMutex); 1905 mFrameEventHistory.addPostComposition(mCurrentFrameNumber, 1906 glDoneFence, presentFence, compositorTiming); 1907 mFrameEventHistory.addRetire(mPreviousFrameNumber, 1908 retireFence); 1909 } 1910 1911 // Update mFrameTracker. 1912 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 1913 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 1914 1915 std::shared_ptr<FenceTime> frameReadyFence = 1916 mSurfaceFlingerConsumer->getCurrentFenceTime(); 1917 if (frameReadyFence->isValid()) { 1918 mFrameTracker.setFrameReadyFence(std::move(frameReadyFence)); 1919 } else { 1920 // There was no fence for this frame, so assume that it was ready 1921 // to be presented at the desired present time. 1922 mFrameTracker.setFrameReadyTime(desiredPresentTime); 1923 } 1924 1925 if (presentFence->isValid()) { 1926 mFrameTracker.setActualPresentFence( 1927 std::shared_ptr<FenceTime>(presentFence)); 1928 } else if (retireFence->isValid()) { 1929 mFrameTracker.setActualPresentFence( 1930 std::shared_ptr<FenceTime>(retireFence)); 1931 } else { 1932 // The HWC doesn't support present fences, so use the refresh 1933 // timestamp instead. 1934 mFrameTracker.setActualPresentTime( 1935 mFlinger->getHwComposer().getRefreshTimestamp( 1936 HWC_DISPLAY_PRIMARY)); 1937 } 1938 1939 mFrameTracker.advanceFrame(); 1940 mFrameLatencyNeeded = false; 1941 return true; 1942} 1943 1944#ifdef USE_HWC2 1945void Layer::releasePendingBuffer(nsecs_t dequeueReadyTime) { 1946 mSurfaceFlingerConsumer->releasePendingBuffer(); 1947 auto releaseFenceTime = std::make_shared<FenceTime>( 1948 mSurfaceFlingerConsumer->getPrevFinalReleaseFence()); 1949 mReleaseTimeline.push(releaseFenceTime); 1950 1951 Mutex::Autolock lock(mFrameEventHistoryMutex); 1952 mFrameEventHistory.addRelease( 1953 mPreviousFrameNumber, dequeueReadyTime, std::move(releaseFenceTime)); 1954} 1955#endif 1956 1957bool Layer::isHiddenByPolicy() const { 1958 const Layer::State& s(mDrawingState); 1959 const auto& parent = getParent(); 1960 if (parent != nullptr && parent->isHiddenByPolicy()) { 1961 return true; 1962 } 1963 return s.flags & layer_state_t::eLayerHidden; 1964} 1965 1966bool Layer::isVisible() const { 1967 const Layer::State& s(mDrawingState); 1968#ifdef USE_HWC2 1969 return !(isHiddenByPolicy()) && s.alpha > 0.0f 1970 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1971#else 1972 return !(isHiddenByPolicy()) && s.alpha 1973 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1974#endif 1975} 1976 1977bool Layer::allTransactionsSignaled() { 1978 auto headFrameNumber = getHeadFrameNumber(); 1979 bool matchingFramesFound = false; 1980 bool allTransactionsApplied = true; 1981 Mutex::Autolock lock(mLocalSyncPointMutex); 1982 1983 for (auto& point : mLocalSyncPoints) { 1984 if (point->getFrameNumber() > headFrameNumber) { 1985 break; 1986 } 1987 matchingFramesFound = true; 1988 1989 if (!point->frameIsAvailable()) { 1990 // We haven't notified the remote layer that the frame for 1991 // this point is available yet. Notify it now, and then 1992 // abort this attempt to latch. 1993 point->setFrameAvailable(); 1994 allTransactionsApplied = false; 1995 break; 1996 } 1997 1998 allTransactionsApplied = allTransactionsApplied && point->transactionIsApplied(); 1999 } 2000 return !matchingFramesFound || allTransactionsApplied; 2001} 2002 2003Region Layer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime) 2004{ 2005 ATRACE_CALL(); 2006 2007 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { 2008 // mSidebandStreamChanged was true 2009 mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream(); 2010 if (mSidebandStream != NULL) { 2011 setTransactionFlags(eTransactionNeeded); 2012 mFlinger->setTransactionFlags(eTraversalNeeded); 2013 } 2014 recomputeVisibleRegions = true; 2015 2016 const State& s(getDrawingState()); 2017 return getTransform().transform(Region(Rect(s.active.w, s.active.h))); 2018 } 2019 2020 Region outDirtyRegion; 2021 if (mQueuedFrames <= 0 && !mAutoRefresh) { 2022 return outDirtyRegion; 2023 } 2024 2025 // if we've already called updateTexImage() without going through 2026 // a composition step, we have to skip this layer at this point 2027 // because we cannot call updateTeximage() without a corresponding 2028 // compositionComplete() call. 2029 // we'll trigger an update in onPreComposition(). 2030 if (mRefreshPending) { 2031 return outDirtyRegion; 2032 } 2033 2034 // If the head buffer's acquire fence hasn't signaled yet, return and 2035 // try again later 2036 if (!headFenceHasSignaled()) { 2037 mFlinger->signalLayerUpdate(); 2038 return outDirtyRegion; 2039 } 2040 2041 // Capture the old state of the layer for comparisons later 2042 const State& s(getDrawingState()); 2043 const bool oldOpacity = isOpaque(s); 2044 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 2045 2046 if (!allTransactionsSignaled()) { 2047 mFlinger->signalLayerUpdate(); 2048 return outDirtyRegion; 2049 } 2050 2051 // This boolean is used to make sure that SurfaceFlinger's shadow copy 2052 // of the buffer queue isn't modified when the buffer queue is returning 2053 // BufferItem's that weren't actually queued. This can happen in shared 2054 // buffer mode. 2055 bool queuedBuffer = false; 2056 LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 2057 getProducerStickyTransform() != 0, mName.string(), 2058 mOverrideScalingMode, mFreezePositionUpdates); 2059 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, 2060 mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer, 2061 mLastFrameNumberReceived); 2062 if (updateResult == BufferQueue::PRESENT_LATER) { 2063 // Producer doesn't want buffer to be displayed yet. Signal a 2064 // layer update so we check again at the next opportunity. 2065 mFlinger->signalLayerUpdate(); 2066 return outDirtyRegion; 2067 } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) { 2068 // If the buffer has been rejected, remove it from the shadow queue 2069 // and return early 2070 if (queuedBuffer) { 2071 Mutex::Autolock lock(mQueueItemLock); 2072 mQueueItems.removeAt(0); 2073 android_atomic_dec(&mQueuedFrames); 2074 } 2075 return outDirtyRegion; 2076 } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { 2077 // This can occur if something goes wrong when trying to create the 2078 // EGLImage for this buffer. If this happens, the buffer has already 2079 // been released, so we need to clean up the queue and bug out 2080 // early. 2081 if (queuedBuffer) { 2082 Mutex::Autolock lock(mQueueItemLock); 2083 mQueueItems.clear(); 2084 android_atomic_and(0, &mQueuedFrames); 2085 } 2086 2087 // Once we have hit this state, the shadow queue may no longer 2088 // correctly reflect the incoming BufferQueue's contents, so even if 2089 // updateTexImage starts working, the only safe course of action is 2090 // to continue to ignore updates. 2091 mUpdateTexImageFailed = true; 2092 2093 return outDirtyRegion; 2094 } 2095 2096 if (queuedBuffer) { 2097 // Autolock scope 2098 auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2099 2100 Mutex::Autolock lock(mQueueItemLock); 2101 2102 // Remove any stale buffers that have been dropped during 2103 // updateTexImage 2104 while (mQueueItems[0].mFrameNumber != currentFrameNumber) { 2105 mQueueItems.removeAt(0); 2106 android_atomic_dec(&mQueuedFrames); 2107 } 2108 2109 mQueueItems.removeAt(0); 2110 } 2111 2112 2113 // Decrement the queued-frames count. Signal another event if we 2114 // have more frames pending. 2115 if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) 2116 || mAutoRefresh) { 2117 mFlinger->signalLayerUpdate(); 2118 } 2119 2120 // update the active buffer 2121 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer( 2122 &mActiveBufferSlot); 2123 if (mActiveBuffer == NULL) { 2124 // this can only happen if the very first buffer was rejected. 2125 return outDirtyRegion; 2126 } 2127 2128 mBufferLatched = true; 2129 mPreviousFrameNumber = mCurrentFrameNumber; 2130 mCurrentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2131 2132 { 2133 Mutex::Autolock lock(mFrameEventHistoryMutex); 2134 mFrameEventHistory.addLatch(mCurrentFrameNumber, latchTime); 2135#ifndef USE_HWC2 2136 auto releaseFenceTime = std::make_shared<FenceTime>( 2137 mSurfaceFlingerConsumer->getPrevFinalReleaseFence()); 2138 mReleaseTimeline.push(releaseFenceTime); 2139 mFrameEventHistory.addRelease( 2140 mPreviousFrameNumber, latchTime, std::move(releaseFenceTime)); 2141#endif 2142 } 2143 2144 mRefreshPending = true; 2145 mFrameLatencyNeeded = true; 2146 if (oldActiveBuffer == NULL) { 2147 // the first time we receive a buffer, we need to trigger a 2148 // geometry invalidation. 2149 recomputeVisibleRegions = true; 2150 } 2151 2152 setDataSpace(mSurfaceFlingerConsumer->getCurrentDataSpace()); 2153 2154 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 2155 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 2156 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 2157 if ((crop != mCurrentCrop) || 2158 (transform != mCurrentTransform) || 2159 (scalingMode != mCurrentScalingMode)) 2160 { 2161 mCurrentCrop = crop; 2162 mCurrentTransform = transform; 2163 mCurrentScalingMode = scalingMode; 2164 recomputeVisibleRegions = true; 2165 } 2166 2167 if (oldActiveBuffer != NULL) { 2168 uint32_t bufWidth = mActiveBuffer->getWidth(); 2169 uint32_t bufHeight = mActiveBuffer->getHeight(); 2170 if (bufWidth != uint32_t(oldActiveBuffer->width) || 2171 bufHeight != uint32_t(oldActiveBuffer->height)) { 2172 recomputeVisibleRegions = true; 2173 } 2174 } 2175 2176 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 2177 if (oldOpacity != isOpaque(s)) { 2178 recomputeVisibleRegions = true; 2179 } 2180 2181 // Remove any sync points corresponding to the buffer which was just 2182 // latched 2183 { 2184 Mutex::Autolock lock(mLocalSyncPointMutex); 2185 auto point = mLocalSyncPoints.begin(); 2186 while (point != mLocalSyncPoints.end()) { 2187 if (!(*point)->frameIsAvailable() || 2188 !(*point)->transactionIsApplied()) { 2189 // This sync point must have been added since we started 2190 // latching. Don't drop it yet. 2191 ++point; 2192 continue; 2193 } 2194 2195 if ((*point)->getFrameNumber() <= mCurrentFrameNumber) { 2196 point = mLocalSyncPoints.erase(point); 2197 } else { 2198 ++point; 2199 } 2200 } 2201 } 2202 2203 // FIXME: postedRegion should be dirty & bounds 2204 Region dirtyRegion(Rect(s.active.w, s.active.h)); 2205 2206 // transform the dirty region to window-manager space 2207 outDirtyRegion = (getTransform().transform(dirtyRegion)); 2208 2209 return outDirtyRegion; 2210} 2211 2212uint32_t Layer::getEffectiveUsage(uint32_t usage) const 2213{ 2214 // TODO: should we do something special if mSecure is set? 2215 if (mProtectedByApp) { 2216 // need a hardware-protected path to external video sink 2217 usage |= GraphicBuffer::USAGE_PROTECTED; 2218 } 2219 if (mPotentialCursor) { 2220 usage |= GraphicBuffer::USAGE_CURSOR; 2221 } 2222 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 2223 return usage; 2224} 2225 2226void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 2227 uint32_t orientation = 0; 2228 if (!mFlinger->mDebugDisableTransformHint) { 2229 // The transform hint is used to improve performance, but we can 2230 // only have a single transform hint, it cannot 2231 // apply to all displays. 2232 const Transform& planeTransform(hw->getTransform()); 2233 orientation = planeTransform.getOrientation(); 2234 if (orientation & Transform::ROT_INVALID) { 2235 orientation = 0; 2236 } 2237 } 2238 mSurfaceFlingerConsumer->setTransformHint(orientation); 2239} 2240 2241// ---------------------------------------------------------------------------- 2242// debugging 2243// ---------------------------------------------------------------------------- 2244 2245void Layer::dump(String8& result, Colorizer& colorizer) const 2246{ 2247 const Layer::State& s(getDrawingState()); 2248 2249 colorizer.colorize(result, Colorizer::GREEN); 2250 result.appendFormat( 2251 "+ %s %p (%s)\n", 2252 getTypeId(), this, getName().string()); 2253 colorizer.reset(result); 2254 2255 s.activeTransparentRegion.dump(result, "transparentRegion"); 2256 visibleRegion.dump(result, "visibleRegion"); 2257 surfaceDamageRegion.dump(result, "surfaceDamageRegion"); 2258 sp<Client> client(mClientRef.promote()); 2259 2260 result.appendFormat( " " 2261 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), " 2262 "crop=(%4d,%4d,%4d,%4d), finalCrop=(%4d,%4d,%4d,%4d), " 2263 "isOpaque=%1d, invalidate=%1d, " 2264#ifdef USE_HWC2 2265 "alpha=%.3f, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2266#else 2267 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2268#endif 2269 " client=%p\n", 2270 getLayerStack(), s.z, 2271 s.active.transform.tx(), s.active.transform.ty(), 2272 s.active.w, s.active.h, 2273 s.crop.left, s.crop.top, 2274 s.crop.right, s.crop.bottom, 2275 s.finalCrop.left, s.finalCrop.top, 2276 s.finalCrop.right, s.finalCrop.bottom, 2277 isOpaque(s), contentDirty, 2278 s.alpha, s.flags, 2279 s.active.transform[0][0], s.active.transform[0][1], 2280 s.active.transform[1][0], s.active.transform[1][1], 2281 client.get()); 2282 2283 sp<const GraphicBuffer> buf0(mActiveBuffer); 2284 uint32_t w0=0, h0=0, s0=0, f0=0; 2285 if (buf0 != 0) { 2286 w0 = buf0->getWidth(); 2287 h0 = buf0->getHeight(); 2288 s0 = buf0->getStride(); 2289 f0 = buf0->format; 2290 } 2291 result.appendFormat( 2292 " " 2293 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 2294 " queued-frames=%d, mRefreshPending=%d\n", 2295 mFormat, w0, h0, s0,f0, 2296 mQueuedFrames, mRefreshPending); 2297 2298 if (mSurfaceFlingerConsumer != 0) { 2299 mSurfaceFlingerConsumer->dumpState(result, " "); 2300 } 2301} 2302 2303#ifdef USE_HWC2 2304void Layer::miniDumpHeader(String8& result) { 2305 result.append("----------------------------------------"); 2306 result.append("---------------------------------------\n"); 2307 result.append(" Layer name\n"); 2308 result.append(" Z | "); 2309 result.append(" Comp Type | "); 2310 result.append(" Disp Frame (LTRB) | "); 2311 result.append(" Source Crop (LTRB)\n"); 2312 result.append("----------------------------------------"); 2313 result.append("---------------------------------------\n"); 2314} 2315 2316void Layer::miniDump(String8& result, int32_t hwcId) const { 2317 if (mHwcLayers.count(hwcId) == 0) { 2318 return; 2319 } 2320 2321 String8 name; 2322 if (mName.length() > 77) { 2323 std::string shortened; 2324 shortened.append(mName.string(), 36); 2325 shortened.append("[...]"); 2326 shortened.append(mName.string() + (mName.length() - 36), 36); 2327 name = shortened.c_str(); 2328 } else { 2329 name = mName; 2330 } 2331 2332 result.appendFormat(" %s\n", name.string()); 2333 2334 const Layer::State& layerState(getDrawingState()); 2335 const HWCInfo& hwcInfo = mHwcLayers.at(hwcId); 2336 result.appendFormat(" %10u | ", layerState.z); 2337 result.appendFormat("%10s | ", 2338 to_string(getCompositionType(hwcId)).c_str()); 2339 const Rect& frame = hwcInfo.displayFrame; 2340 result.appendFormat("%4d %4d %4d %4d | ", frame.left, frame.top, 2341 frame.right, frame.bottom); 2342 const gfx::FloatRect& crop = hwcInfo.sourceCrop; 2343 result.appendFormat("%6.1f %6.1f %6.1f %6.1f\n", crop.left, crop.top, 2344 crop.right, crop.bottom); 2345 2346 result.append("- - - - - - - - - - - - - - - - - - - - "); 2347 result.append("- - - - - - - - - - - - - - - - - - - -\n"); 2348} 2349#endif 2350 2351void Layer::dumpFrameStats(String8& result) const { 2352 mFrameTracker.dumpStats(result); 2353} 2354 2355void Layer::clearFrameStats() { 2356 mFrameTracker.clearStats(); 2357} 2358 2359void Layer::logFrameStats() { 2360 mFrameTracker.logAndResetStats(mName); 2361} 2362 2363void Layer::getFrameStats(FrameStats* outStats) const { 2364 mFrameTracker.getStats(outStats); 2365} 2366 2367void Layer::dumpFrameEvents(String8& result) { 2368 result.appendFormat("- Layer %s (%s, %p)\n", 2369 getName().string(), getTypeId(), this); 2370 Mutex::Autolock lock(mFrameEventHistoryMutex); 2371 mFrameEventHistory.checkFencesForCompletion(); 2372 mFrameEventHistory.dump(result); 2373} 2374 2375void Layer::addAndGetFrameTimestamps(const NewFrameEventsEntry* newTimestamps, 2376 FrameEventHistoryDelta *outDelta) { 2377 Mutex::Autolock lock(mFrameEventHistoryMutex); 2378 if (newTimestamps) { 2379 mAcquireTimeline.push(newTimestamps->acquireFence); 2380 mFrameEventHistory.addQueue(*newTimestamps); 2381 } 2382 2383 if (outDelta) { 2384 mFrameEventHistory.getAndResetDelta(outDelta); 2385 } 2386} 2387 2388std::vector<OccupancyTracker::Segment> Layer::getOccupancyHistory( 2389 bool forceFlush) { 2390 std::vector<OccupancyTracker::Segment> history; 2391 status_t result = mSurfaceFlingerConsumer->getOccupancyHistory(forceFlush, 2392 &history); 2393 if (result != NO_ERROR) { 2394 ALOGW("[%s] Failed to obtain occupancy history (%d)", mName.string(), 2395 result); 2396 return {}; 2397 } 2398 return history; 2399} 2400 2401bool Layer::getTransformToDisplayInverse() const { 2402 return mSurfaceFlingerConsumer->getTransformToDisplayInverse(); 2403} 2404 2405void Layer::addChild(const sp<Layer>& layer) { 2406 mCurrentChildren.add(layer); 2407 layer->setParent(this); 2408} 2409 2410ssize_t Layer::removeChild(const sp<Layer>& layer) { 2411 layer->setParent(nullptr); 2412 return mCurrentChildren.remove(layer); 2413} 2414 2415bool Layer::reparentChildren(const sp<IBinder>& newParentHandle) { 2416 sp<Handle> handle = nullptr; 2417 sp<Layer> newParent = nullptr; 2418 if (newParentHandle == nullptr) { 2419 return false; 2420 } 2421 handle = static_cast<Handle*>(newParentHandle.get()); 2422 newParent = handle->owner.promote(); 2423 if (newParent == nullptr) { 2424 ALOGE("Unable to promote Layer handle"); 2425 return false; 2426 } 2427 2428 for (const sp<Layer>& child : mCurrentChildren) { 2429 newParent->addChild(child); 2430 2431 sp<Client> client(child->mClientRef.promote()); 2432 if (client != nullptr) { 2433 client->setParentLayer(newParent); 2434 } 2435 } 2436 mCurrentChildren.clear(); 2437 2438 return true; 2439} 2440 2441void Layer::setParent(const sp<Layer>& layer) { 2442 mParent = layer; 2443} 2444 2445void Layer::clearSyncPoints() { 2446 for (const auto& child : mCurrentChildren) { 2447 child->clearSyncPoints(); 2448 } 2449 2450 Mutex::Autolock lock(mLocalSyncPointMutex); 2451 for (auto& point : mLocalSyncPoints) { 2452 point->setFrameAvailable(); 2453 } 2454 mLocalSyncPoints.clear(); 2455} 2456 2457int32_t Layer::getZ() const { 2458 return mDrawingState.z; 2459} 2460 2461/** 2462 * Negatively signed children are before 'this' in Z-order. 2463 */ 2464void Layer::traverseInZOrder(const std::function<void(Layer*)>& exec) { 2465 size_t i = 0; 2466 for (; i < mDrawingChildren.size(); i++) { 2467 const auto& child = mDrawingChildren[i]; 2468 if (child->getZ() >= 0) 2469 break; 2470 child->traverseInZOrder(exec); 2471 } 2472 exec(this); 2473 for (; i < mDrawingChildren.size(); i++) { 2474 const auto& child = mDrawingChildren[i]; 2475 child->traverseInZOrder(exec); 2476 } 2477} 2478 2479/** 2480 * Positively signed children are before 'this' in reverse Z-order. 2481 */ 2482void Layer::traverseInReverseZOrder(const std::function<void(Layer*)>& exec) { 2483 int32_t i = 0; 2484 for (i = mDrawingChildren.size()-1; i>=0; i--) { 2485 const auto& child = mDrawingChildren[i]; 2486 if (child->getZ() < 0) { 2487 break; 2488 } 2489 child->traverseInReverseZOrder(exec); 2490 } 2491 exec(this); 2492 for (; i>=0; i--) { 2493 const auto& child = mDrawingChildren[i]; 2494 child->traverseInReverseZOrder(exec); 2495 } 2496} 2497 2498Transform Layer::getTransform() const { 2499 Transform t; 2500 const auto& p = getParent(); 2501 if (p != nullptr) { 2502 t = p->getTransform(); 2503 } 2504 return t * getDrawingState().active.transform; 2505} 2506 2507void Layer::commitChildList() { 2508 for (size_t i = 0; i < mCurrentChildren.size(); i++) { 2509 const auto& child = mCurrentChildren[i]; 2510 child->commitChildList(); 2511 } 2512 mDrawingChildren = mCurrentChildren; 2513} 2514 2515// --------------------------------------------------------------------------- 2516 2517}; // namespace android 2518 2519#if defined(__gl_h_) 2520#error "don't include gl/gl.h in this file" 2521#endif 2522 2523#if defined(__gl2_h_) 2524#error "don't include gl2/gl2.h in this file" 2525#endif 2526