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