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