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