Layer.cpp revision 3569f1fe4e7faf64720c6e023bfdf76347f5b2b6
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#include <mutex> 55 56#define DEBUG_RESIZE 0 57 58namespace android { 59 60// --------------------------------------------------------------------------- 61 62int32_t Layer::sSequence = 1; 63 64Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client, 65 const String8& name, uint32_t w, uint32_t h, uint32_t flags) 66 : contentDirty(false), 67 sequence(uint32_t(android_atomic_inc(&sSequence))), 68 mFlinger(flinger), 69 mTextureName(-1U), 70 mPremultipliedAlpha(true), 71 mName("unnamed"), 72 mFormat(PIXEL_FORMAT_NONE), 73 mTransactionFlags(0), 74 mPendingStateMutex(), 75 mPendingStates(), 76 mQueuedFrames(0), 77 mSidebandStreamChanged(false), 78 mCurrentTransform(0), 79 mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), 80 mOverrideScalingMode(-1), 81 mCurrentOpacity(true), 82 mCurrentFrameNumber(0), 83 mRefreshPending(false), 84 mFrameLatencyNeeded(false), 85 mFiltering(false), 86 mNeedsFiltering(false), 87 mMesh(Mesh::TRIANGLE_FAN, 4, 2, 2), 88#ifndef USE_HWC2 89 mIsGlesComposition(false), 90#endif 91 mProtectedByApp(false), 92 mHasSurface(false), 93 mClientRef(client), 94 mPotentialCursor(false), 95 mQueueItemLock(), 96 mQueueItemCondition(), 97 mQueueItems(), 98 mLastFrameNumberReceived(0), 99 mUpdateTexImageFailed(false), 100 mAutoRefresh(false), 101 mFreezePositionUpdates(false) 102{ 103#ifdef USE_HWC2 104 ALOGV("Creating Layer %s", name.string()); 105#endif 106 107 mCurrentCrop.makeInvalid(); 108 mFlinger->getRenderEngine().genTextures(1, &mTextureName); 109 mTexture.init(Texture::TEXTURE_EXTERNAL, mTextureName); 110 111 uint32_t layerFlags = 0; 112 if (flags & ISurfaceComposerClient::eHidden) 113 layerFlags |= layer_state_t::eLayerHidden; 114 if (flags & ISurfaceComposerClient::eOpaque) 115 layerFlags |= layer_state_t::eLayerOpaque; 116 if (flags & ISurfaceComposerClient::eSecure) 117 layerFlags |= layer_state_t::eLayerSecure; 118 119 if (flags & ISurfaceComposerClient::eNonPremultiplied) 120 mPremultipliedAlpha = false; 121 122 mName = name; 123 124 mCurrentState.active.w = w; 125 mCurrentState.active.h = h; 126 mCurrentState.active.transform.set(0, 0); 127 mCurrentState.crop.makeInvalid(); 128 mCurrentState.finalCrop.makeInvalid(); 129 mCurrentState.z = 0; 130#ifdef USE_HWC2 131 mCurrentState.alpha = 1.0f; 132#else 133 mCurrentState.alpha = 0xFF; 134#endif 135 mCurrentState.layerStack = 0; 136 mCurrentState.flags = layerFlags; 137 mCurrentState.sequence = 0; 138 mCurrentState.requested = mCurrentState.active; 139 140 // drawing state & current state are identical 141 mDrawingState = mCurrentState; 142 143#ifdef USE_HWC2 144 const auto& hwc = flinger->getHwComposer(); 145 const auto& activeConfig = hwc.getActiveConfig(HWC_DISPLAY_PRIMARY); 146 nsecs_t displayPeriod = activeConfig->getVsyncPeriod(); 147#else 148 nsecs_t displayPeriod = 149 flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 150#endif 151 mFrameTracker.setDisplayRefreshPeriod(displayPeriod); 152} 153 154void Layer::onFirstRef() { 155 // Creates a custom BufferQueue for SurfaceFlingerConsumer to use 156 sp<IGraphicBufferProducer> producer; 157 sp<IGraphicBufferConsumer> consumer; 158 BufferQueue::createBufferQueue(&producer, &consumer); 159 mProducer = new MonitoredProducer(producer, mFlinger); 160 mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName, 161 this); 162 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 163 mSurfaceFlingerConsumer->setContentsChangedListener(this); 164 mSurfaceFlingerConsumer->setName(mName); 165 166#ifndef TARGET_DISABLE_TRIPLE_BUFFERING 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 return; 730 } 731 732 // Device or Cursor layers 733 if (mPotentialCursor) { 734 ALOGV("[%s] Requesting Cursor composition", mName.string()); 735 setCompositionType(hwcId, HWC2::Composition::Cursor); 736 } else { 737 ALOGV("[%s] Requesting Device composition", mName.string()); 738 setCompositionType(hwcId, HWC2::Composition::Device); 739 } 740 741 auto acquireFence = mSurfaceFlingerConsumer->getCurrentFence(); 742 error = hwcLayer->setBuffer(mActiveBuffer->handle, acquireFence); 743 if (error != HWC2::Error::None) { 744 ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(), 745 mActiveBuffer->handle, to_string(error).c_str(), 746 static_cast<int32_t>(error)); 747 } 748} 749#else 750void Layer::setPerFrameData(const sp<const DisplayDevice>& hw, 751 HWComposer::HWCLayerInterface& layer) { 752 // we have to set the visible region on every frame because 753 // we currently free it during onLayerDisplayed(), which is called 754 // after HWComposer::commit() -- every frame. 755 // Apply this display's projection's viewport to the visible region 756 // before giving it to the HWC HAL. 757 const Transform& tr = hw->getTransform(); 758 Region visible = tr.transform(visibleRegion.intersect(hw->getViewport())); 759 layer.setVisibleRegionScreen(visible); 760 layer.setSurfaceDamage(surfaceDamageRegion); 761 mIsGlesComposition = (layer.getCompositionType() == HWC_FRAMEBUFFER); 762 763 if (mSidebandStream.get()) { 764 layer.setSidebandStream(mSidebandStream); 765 } else { 766 // NOTE: buffer can be NULL if the client never drew into this 767 // layer yet, or if we ran out of memory 768 layer.setBuffer(mActiveBuffer); 769 } 770} 771#endif 772 773#ifdef USE_HWC2 774void Layer::updateCursorPosition(const sp<const DisplayDevice>& displayDevice) { 775 auto hwcId = displayDevice->getHwcDisplayId(); 776 if (mHwcLayers.count(hwcId) == 0 || 777 getCompositionType(hwcId) != HWC2::Composition::Cursor) { 778 return; 779 } 780 781 // This gives us only the "orientation" component of the transform 782 const State& s(getCurrentState()); 783 784 // Apply the layer's transform, followed by the display's global transform 785 // Here we're guaranteed that the layer's transform preserves rects 786 Rect win(s.active.w, s.active.h); 787 if (!s.crop.isEmpty()) { 788 win.intersect(s.crop, &win); 789 } 790 // Subtract the transparent region and snap to the bounds 791 Rect bounds = reduce(win, s.activeTransparentRegion); 792 Rect frame(s.active.transform.transform(bounds)); 793 frame.intersect(displayDevice->getViewport(), &frame); 794 if (!s.finalCrop.isEmpty()) { 795 frame.intersect(s.finalCrop, &frame); 796 } 797 auto& displayTransform(displayDevice->getTransform()); 798 auto position = displayTransform.transform(frame); 799 800 auto error = mHwcLayers[hwcId].layer->setCursorPosition(position.left, 801 position.top); 802 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set cursor position " 803 "to (%d, %d): %s (%d)", mName.string(), position.left, 804 position.top, to_string(error).c_str(), 805 static_cast<int32_t>(error)); 806} 807#else 808void Layer::setAcquireFence(const sp<const DisplayDevice>& /* hw */, 809 HWComposer::HWCLayerInterface& layer) { 810 int fenceFd = -1; 811 812 // TODO: there is a possible optimization here: we only need to set the 813 // acquire fence the first time a new buffer is acquired on EACH display. 814 815 if (layer.getCompositionType() == HWC_OVERLAY || layer.getCompositionType() == HWC_CURSOR_OVERLAY) { 816 sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence(); 817 if (fence->isValid()) { 818 fenceFd = fence->dup(); 819 if (fenceFd == -1) { 820 ALOGW("failed to dup layer fence, skipping sync: %d", errno); 821 } 822 } 823 } 824 layer.setAcquireFenceFd(fenceFd); 825} 826 827Rect Layer::getPosition( 828 const sp<const DisplayDevice>& hw) 829{ 830 // this gives us only the "orientation" component of the transform 831 const State& s(getCurrentState()); 832 833 // apply the layer's transform, followed by the display's global transform 834 // here we're guaranteed that the layer's transform preserves rects 835 Rect win(s.active.w, s.active.h); 836 if (!s.crop.isEmpty()) { 837 win.intersect(s.crop, &win); 838 } 839 // subtract the transparent region and snap to the bounds 840 Rect bounds = reduce(win, s.activeTransparentRegion); 841 Rect frame(s.active.transform.transform(bounds)); 842 frame.intersect(hw->getViewport(), &frame); 843 if (!s.finalCrop.isEmpty()) { 844 frame.intersect(s.finalCrop, &frame); 845 } 846 const Transform& tr(hw->getTransform()); 847 return Rect(tr.transform(frame)); 848} 849#endif 850 851// --------------------------------------------------------------------------- 852// drawing... 853// --------------------------------------------------------------------------- 854 855void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const { 856 onDraw(hw, clip, false); 857} 858 859void Layer::draw(const sp<const DisplayDevice>& hw, 860 bool useIdentityTransform) const { 861 onDraw(hw, Region(hw->bounds()), useIdentityTransform); 862} 863 864void Layer::draw(const sp<const DisplayDevice>& hw) const { 865 onDraw(hw, Region(hw->bounds()), false); 866} 867 868void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip, 869 bool useIdentityTransform) const 870{ 871 ATRACE_CALL(); 872 873 if (CC_UNLIKELY(mActiveBuffer == 0)) { 874 // the texture has not been created yet, this Layer has 875 // in fact never been drawn into. This happens frequently with 876 // SurfaceView because the WindowManager can't know when the client 877 // has drawn the first time. 878 879 // If there is nothing under us, we paint the screen in black, otherwise 880 // we just skip this update. 881 882 // figure out if there is something below us 883 Region under; 884 const SurfaceFlinger::LayerVector& drawingLayers( 885 mFlinger->mDrawingState.layersSortedByZ); 886 const size_t count = drawingLayers.size(); 887 for (size_t i=0 ; i<count ; ++i) { 888 const sp<Layer>& layer(drawingLayers[i]); 889 if (layer.get() == static_cast<Layer const*>(this)) 890 break; 891 under.orSelf( hw->getTransform().transform(layer->visibleRegion) ); 892 } 893 // if not everything below us is covered, we plug the holes! 894 Region holes(clip.subtract(under)); 895 if (!holes.isEmpty()) { 896 clearWithOpenGL(hw, holes, 0, 0, 0, 1); 897 } 898 return; 899 } 900 901 // Bind the current buffer to the GL texture, and wait for it to be 902 // ready for us to draw into. 903 status_t err = mSurfaceFlingerConsumer->bindTextureImage(); 904 if (err != NO_ERROR) { 905 ALOGW("onDraw: bindTextureImage failed (err=%d)", err); 906 // Go ahead and draw the buffer anyway; no matter what we do the screen 907 // is probably going to have something visibly wrong. 908 } 909 910 bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure()); 911 912 RenderEngine& engine(mFlinger->getRenderEngine()); 913 914 if (!blackOutLayer) { 915 // TODO: we could be more subtle with isFixedSize() 916 const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize(); 917 918 // Query the texture matrix given our current filtering mode. 919 float textureMatrix[16]; 920 mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering); 921 mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix); 922 923 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { 924 925 /* 926 * the code below applies the primary display's inverse transform to 927 * the texture transform 928 */ 929 930 // create a 4x4 transform matrix from the display transform flags 931 const mat4 flipH(-1,0,0,0, 0,1,0,0, 0,0,1,0, 1,0,0,1); 932 const mat4 flipV( 1,0,0,0, 0,-1,0,0, 0,0,1,0, 0,1,0,1); 933 const mat4 rot90( 0,1,0,0, -1,0,0,0, 0,0,1,0, 1,0,0,1); 934 935 mat4 tr; 936 uint32_t transform = 937 DisplayDevice::getPrimaryDisplayOrientationTransform(); 938 if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90) 939 tr = tr * rot90; 940 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H) 941 tr = tr * flipH; 942 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V) 943 tr = tr * flipV; 944 945 // calculate the inverse 946 tr = inverse(tr); 947 948 // and finally apply it to the original texture matrix 949 const mat4 texTransform(mat4(static_cast<const float*>(textureMatrix)) * tr); 950 memcpy(textureMatrix, texTransform.asArray(), sizeof(textureMatrix)); 951 } 952 953 // Set things up for texturing. 954 mTexture.setDimensions(mActiveBuffer->getWidth(), mActiveBuffer->getHeight()); 955 mTexture.setFiltering(useFiltering); 956 mTexture.setMatrix(textureMatrix); 957 958 engine.setupLayerTexturing(mTexture); 959 } else { 960 engine.setupLayerBlackedOut(); 961 } 962 drawWithOpenGL(hw, clip, useIdentityTransform); 963 engine.disableTexturing(); 964} 965 966 967void Layer::clearWithOpenGL(const sp<const DisplayDevice>& hw, 968 const Region& /* clip */, float red, float green, float blue, 969 float alpha) const 970{ 971 RenderEngine& engine(mFlinger->getRenderEngine()); 972 computeGeometry(hw, mMesh, false); 973 engine.setupFillWithColor(red, green, blue, alpha); 974 engine.drawMesh(mMesh); 975} 976 977void Layer::clearWithOpenGL( 978 const sp<const DisplayDevice>& hw, const Region& clip) const { 979 clearWithOpenGL(hw, clip, 0,0,0,0); 980} 981 982void Layer::drawWithOpenGL(const sp<const DisplayDevice>& hw, 983 const Region& /* clip */, bool useIdentityTransform) const { 984 const State& s(getDrawingState()); 985 986 computeGeometry(hw, mMesh, useIdentityTransform); 987 988 /* 989 * NOTE: the way we compute the texture coordinates here produces 990 * different results than when we take the HWC path -- in the later case 991 * the "source crop" is rounded to texel boundaries. 992 * This can produce significantly different results when the texture 993 * is scaled by a large amount. 994 * 995 * The GL code below is more logical (imho), and the difference with 996 * HWC is due to a limitation of the HWC API to integers -- a question 997 * is suspend is whether we should ignore this problem or revert to 998 * GL composition when a buffer scaling is applied (maybe with some 999 * minimal value)? Or, we could make GL behave like HWC -- but this feel 1000 * like more of a hack. 1001 */ 1002 Rect win(computeBounds()); 1003 1004 if (!s.finalCrop.isEmpty()) { 1005 win = s.active.transform.transform(win); 1006 if (!win.intersect(s.finalCrop, &win)) { 1007 win.clear(); 1008 } 1009 win = s.active.transform.inverse().transform(win); 1010 if (!win.intersect(computeBounds(), &win)) { 1011 win.clear(); 1012 } 1013 } 1014 1015 float left = float(win.left) / float(s.active.w); 1016 float top = float(win.top) / float(s.active.h); 1017 float right = float(win.right) / float(s.active.w); 1018 float bottom = float(win.bottom) / float(s.active.h); 1019 1020 // TODO: we probably want to generate the texture coords with the mesh 1021 // here we assume that we only have 4 vertices 1022 Mesh::VertexArray<vec2> texCoords(mMesh.getTexCoordArray<vec2>()); 1023 texCoords[0] = vec2(left, 1.0f - top); 1024 texCoords[1] = vec2(left, 1.0f - bottom); 1025 texCoords[2] = vec2(right, 1.0f - bottom); 1026 texCoords[3] = vec2(right, 1.0f - top); 1027 1028 RenderEngine& engine(mFlinger->getRenderEngine()); 1029 engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), s.alpha); 1030 engine.drawMesh(mMesh); 1031 engine.disableBlending(); 1032} 1033 1034#ifdef USE_HWC2 1035void Layer::setCompositionType(int32_t hwcId, HWC2::Composition type, 1036 bool callIntoHwc) { 1037 if (mHwcLayers.count(hwcId) == 0) { 1038 ALOGE("setCompositionType called without a valid HWC layer"); 1039 return; 1040 } 1041 auto& hwcInfo = mHwcLayers[hwcId]; 1042 auto& hwcLayer = hwcInfo.layer; 1043 ALOGV("setCompositionType(%" PRIx64 ", %s, %d)", hwcLayer->getId(), 1044 to_string(type).c_str(), static_cast<int>(callIntoHwc)); 1045 if (hwcInfo.compositionType != type) { 1046 ALOGV(" actually setting"); 1047 hwcInfo.compositionType = type; 1048 if (callIntoHwc) { 1049 auto error = hwcLayer->setCompositionType(type); 1050 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set " 1051 "composition type %s: %s (%d)", mName.string(), 1052 to_string(type).c_str(), to_string(error).c_str(), 1053 static_cast<int32_t>(error)); 1054 } 1055 } 1056} 1057 1058HWC2::Composition Layer::getCompositionType(int32_t hwcId) const { 1059 if (mHwcLayers.count(hwcId) == 0) { 1060 ALOGE("getCompositionType called without a valid HWC layer"); 1061 return HWC2::Composition::Invalid; 1062 } 1063 return mHwcLayers.at(hwcId).compositionType; 1064} 1065 1066void Layer::setClearClientTarget(int32_t hwcId, bool clear) { 1067 if (mHwcLayers.count(hwcId) == 0) { 1068 ALOGE("setClearClientTarget called without a valid HWC layer"); 1069 return; 1070 } 1071 mHwcLayers[hwcId].clearClientTarget = clear; 1072} 1073 1074bool Layer::getClearClientTarget(int32_t hwcId) const { 1075 if (mHwcLayers.count(hwcId) == 0) { 1076 ALOGE("getClearClientTarget called without a valid HWC layer"); 1077 return false; 1078 } 1079 return mHwcLayers.at(hwcId).clearClientTarget; 1080} 1081#endif 1082 1083uint32_t Layer::getProducerStickyTransform() const { 1084 int producerStickyTransform = 0; 1085 int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform); 1086 if (ret != OK) { 1087 ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__, 1088 strerror(-ret), ret); 1089 return 0; 1090 } 1091 return static_cast<uint32_t>(producerStickyTransform); 1092} 1093 1094bool Layer::latchUnsignaledBuffers() { 1095 static bool propertyLoaded = false; 1096 static bool latch = false; 1097 static std::mutex mutex; 1098 std::lock_guard<std::mutex> lock(mutex); 1099 if (!propertyLoaded) { 1100 char value[PROPERTY_VALUE_MAX] = {}; 1101 property_get("debug.sf.latch_unsignaled", value, "0"); 1102 latch = atoi(value); 1103 propertyLoaded = true; 1104 } 1105 return latch; 1106} 1107 1108uint64_t Layer::getHeadFrameNumber() const { 1109 Mutex::Autolock lock(mQueueItemLock); 1110 if (!mQueueItems.empty()) { 1111 return mQueueItems[0].mFrameNumber; 1112 } else { 1113 return mCurrentFrameNumber; 1114 } 1115} 1116 1117bool Layer::headFenceHasSignaled() const { 1118#ifdef USE_HWC2 1119 if (latchUnsignaledBuffers()) { 1120 return true; 1121 } 1122 1123 Mutex::Autolock lock(mQueueItemLock); 1124 if (mQueueItems.empty()) { 1125 return true; 1126 } 1127 if (mQueueItems[0].mIsDroppable) { 1128 // Even though this buffer's fence may not have signaled yet, it could 1129 // be replaced by another buffer before it has a chance to, which means 1130 // that it's possible to get into a situation where a buffer is never 1131 // able to be latched. To avoid this, grab this buffer anyway. 1132 return true; 1133 } 1134 return mQueueItems[0].mFence->getSignalTime() != INT64_MAX; 1135#else 1136 return true; 1137#endif 1138} 1139 1140bool Layer::addSyncPoint(const std::shared_ptr<SyncPoint>& point) { 1141 if (point->getFrameNumber() <= mCurrentFrameNumber) { 1142 // Don't bother with a SyncPoint, since we've already latched the 1143 // relevant frame 1144 return false; 1145 } 1146 1147 Mutex::Autolock lock(mLocalSyncPointMutex); 1148 mLocalSyncPoints.push_back(point); 1149 return true; 1150} 1151 1152void Layer::setFiltering(bool filtering) { 1153 mFiltering = filtering; 1154} 1155 1156bool Layer::getFiltering() const { 1157 return mFiltering; 1158} 1159 1160// As documented in libhardware header, formats in the range 1161// 0x100 - 0x1FF are specific to the HAL implementation, and 1162// are known to have no alpha channel 1163// TODO: move definition for device-specific range into 1164// hardware.h, instead of using hard-coded values here. 1165#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) 1166 1167bool Layer::getOpacityForFormat(uint32_t format) { 1168 if (HARDWARE_IS_DEVICE_FORMAT(format)) { 1169 return true; 1170 } 1171 switch (format) { 1172 case HAL_PIXEL_FORMAT_RGBA_8888: 1173 case HAL_PIXEL_FORMAT_BGRA_8888: 1174 return false; 1175 } 1176 // in all other case, we have no blending (also for unknown formats) 1177 return true; 1178} 1179 1180// ---------------------------------------------------------------------------- 1181// local state 1182// ---------------------------------------------------------------------------- 1183 1184static void boundPoint(vec2* point, const Rect& crop) { 1185 if (point->x < crop.left) { 1186 point->x = crop.left; 1187 } 1188 if (point->x > crop.right) { 1189 point->x = crop.right; 1190 } 1191 if (point->y < crop.top) { 1192 point->y = crop.top; 1193 } 1194 if (point->y > crop.bottom) { 1195 point->y = crop.bottom; 1196 } 1197} 1198 1199void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh, 1200 bool useIdentityTransform) const 1201{ 1202 const Layer::State& s(getDrawingState()); 1203 const Transform tr(hw->getTransform()); 1204 const uint32_t hw_h = hw->getHeight(); 1205 Rect win(s.active.w, s.active.h); 1206 if (!s.crop.isEmpty()) { 1207 win.intersect(s.crop, &win); 1208 } 1209 // subtract the transparent region and snap to the bounds 1210 win = reduce(win, s.activeTransparentRegion); 1211 1212 vec2 lt = vec2(win.left, win.top); 1213 vec2 lb = vec2(win.left, win.bottom); 1214 vec2 rb = vec2(win.right, win.bottom); 1215 vec2 rt = vec2(win.right, win.top); 1216 1217 if (!useIdentityTransform) { 1218 lt = s.active.transform.transform(lt); 1219 lb = s.active.transform.transform(lb); 1220 rb = s.active.transform.transform(rb); 1221 rt = s.active.transform.transform(rt); 1222 } 1223 1224 if (!s.finalCrop.isEmpty()) { 1225 boundPoint(<, s.finalCrop); 1226 boundPoint(&lb, s.finalCrop); 1227 boundPoint(&rb, s.finalCrop); 1228 boundPoint(&rt, s.finalCrop); 1229 } 1230 1231 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>()); 1232 position[0] = tr.transform(lt); 1233 position[1] = tr.transform(lb); 1234 position[2] = tr.transform(rb); 1235 position[3] = tr.transform(rt); 1236 for (size_t i=0 ; i<4 ; i++) { 1237 position[i].y = hw_h - position[i].y; 1238 } 1239} 1240 1241bool Layer::isOpaque(const Layer::State& s) const 1242{ 1243 // if we don't have a buffer yet, we're translucent regardless of the 1244 // layer's opaque flag. 1245 if (mActiveBuffer == 0) { 1246 return false; 1247 } 1248 1249 // if the layer has the opaque flag, then we're always opaque, 1250 // otherwise we use the current buffer's format. 1251 return ((s.flags & layer_state_t::eLayerOpaque) != 0) || mCurrentOpacity; 1252} 1253 1254bool Layer::isSecure() const 1255{ 1256 const Layer::State& s(mDrawingState); 1257 return (s.flags & layer_state_t::eLayerSecure); 1258} 1259 1260bool Layer::isProtected() const 1261{ 1262 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 1263 return (activeBuffer != 0) && 1264 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 1265} 1266 1267bool Layer::isFixedSize() const { 1268 return getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1269} 1270 1271bool Layer::isCropped() const { 1272 return !mCurrentCrop.isEmpty(); 1273} 1274 1275bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const { 1276 return mNeedsFiltering || hw->needsFiltering(); 1277} 1278 1279void Layer::setVisibleRegion(const Region& visibleRegion) { 1280 // always called from main thread 1281 this->visibleRegion = visibleRegion; 1282} 1283 1284void Layer::setCoveredRegion(const Region& coveredRegion) { 1285 // always called from main thread 1286 this->coveredRegion = coveredRegion; 1287} 1288 1289void Layer::setVisibleNonTransparentRegion(const Region& 1290 setVisibleNonTransparentRegion) { 1291 // always called from main thread 1292 this->visibleNonTransparentRegion = setVisibleNonTransparentRegion; 1293} 1294 1295// ---------------------------------------------------------------------------- 1296// transaction 1297// ---------------------------------------------------------------------------- 1298 1299void Layer::pushPendingState() { 1300 if (!mCurrentState.modified) { 1301 return; 1302 } 1303 1304 // If this transaction is waiting on the receipt of a frame, generate a sync 1305 // point and send it to the remote layer. 1306 if (mCurrentState.handle != nullptr) { 1307 sp<Handle> handle = static_cast<Handle*>(mCurrentState.handle.get()); 1308 sp<Layer> handleLayer = handle->owner.promote(); 1309 if (handleLayer == nullptr) { 1310 ALOGE("[%s] Unable to promote Layer handle", mName.string()); 1311 // If we can't promote the layer we are intended to wait on, 1312 // then it is expired or otherwise invalid. Allow this transaction 1313 // to be applied as per normal (no synchronization). 1314 mCurrentState.handle = nullptr; 1315 } else { 1316 auto syncPoint = std::make_shared<SyncPoint>( 1317 mCurrentState.frameNumber); 1318 if (handleLayer->addSyncPoint(syncPoint)) { 1319 mRemoteSyncPoints.push_back(std::move(syncPoint)); 1320 } else { 1321 // We already missed the frame we're supposed to synchronize 1322 // on, so go ahead and apply the state update 1323 mCurrentState.handle = nullptr; 1324 } 1325 } 1326 1327 // Wake us up to check if the frame has been received 1328 setTransactionFlags(eTransactionNeeded); 1329 } 1330 mPendingStates.push_back(mCurrentState); 1331} 1332 1333void Layer::popPendingState(State* stateToCommit) { 1334 auto oldFlags = stateToCommit->flags; 1335 *stateToCommit = mPendingStates[0]; 1336 stateToCommit->flags = (oldFlags & ~stateToCommit->mask) | 1337 (stateToCommit->flags & stateToCommit->mask); 1338 1339 mPendingStates.removeAt(0); 1340} 1341 1342bool Layer::applyPendingStates(State* stateToCommit) { 1343 bool stateUpdateAvailable = false; 1344 while (!mPendingStates.empty()) { 1345 if (mPendingStates[0].handle != nullptr) { 1346 if (mRemoteSyncPoints.empty()) { 1347 // If we don't have a sync point for this, apply it anyway. It 1348 // will be visually wrong, but it should keep us from getting 1349 // into too much trouble. 1350 ALOGE("[%s] No local sync point found", mName.string()); 1351 popPendingState(stateToCommit); 1352 stateUpdateAvailable = true; 1353 continue; 1354 } 1355 1356 if (mRemoteSyncPoints.front()->getFrameNumber() != 1357 mPendingStates[0].frameNumber) { 1358 ALOGE("[%s] Unexpected sync point frame number found", 1359 mName.string()); 1360 1361 // Signal our end of the sync point and then dispose of it 1362 mRemoteSyncPoints.front()->setTransactionApplied(); 1363 mRemoteSyncPoints.pop_front(); 1364 continue; 1365 } 1366 1367 if (mRemoteSyncPoints.front()->frameIsAvailable()) { 1368 // Apply the state update 1369 popPendingState(stateToCommit); 1370 stateUpdateAvailable = true; 1371 1372 // Signal our end of the sync point and then dispose of it 1373 mRemoteSyncPoints.front()->setTransactionApplied(); 1374 mRemoteSyncPoints.pop_front(); 1375 } else { 1376 break; 1377 } 1378 } else { 1379 popPendingState(stateToCommit); 1380 stateUpdateAvailable = true; 1381 } 1382 } 1383 1384 // If we still have pending updates, wake SurfaceFlinger back up and point 1385 // it at this layer so we can process them 1386 if (!mPendingStates.empty()) { 1387 setTransactionFlags(eTransactionNeeded); 1388 mFlinger->setTransactionFlags(eTraversalNeeded); 1389 } 1390 1391 mCurrentState.modified = false; 1392 return stateUpdateAvailable; 1393} 1394 1395void Layer::notifyAvailableFrames() { 1396 auto headFrameNumber = getHeadFrameNumber(); 1397 bool headFenceSignaled = headFenceHasSignaled(); 1398 Mutex::Autolock lock(mLocalSyncPointMutex); 1399 for (auto& point : mLocalSyncPoints) { 1400 if (headFrameNumber >= point->getFrameNumber() && headFenceSignaled) { 1401 point->setFrameAvailable(); 1402 } 1403 } 1404} 1405 1406uint32_t Layer::doTransaction(uint32_t flags) { 1407 ATRACE_CALL(); 1408 1409 pushPendingState(); 1410 Layer::State c = getCurrentState(); 1411 if (!applyPendingStates(&c)) { 1412 return 0; 1413 } 1414 1415 const Layer::State& s(getDrawingState()); 1416 1417 const bool sizeChanged = (c.requested.w != s.requested.w) || 1418 (c.requested.h != s.requested.h); 1419 1420 if (sizeChanged) { 1421 // the size changed, we need to ask our client to request a new buffer 1422 ALOGD_IF(DEBUG_RESIZE, 1423 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 1424 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1425 " requested={ wh={%4u,%4u} }}\n" 1426 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1427 " requested={ wh={%4u,%4u} }}\n", 1428 this, getName().string(), mCurrentTransform, 1429 getEffectiveScalingMode(), 1430 c.active.w, c.active.h, 1431 c.crop.left, 1432 c.crop.top, 1433 c.crop.right, 1434 c.crop.bottom, 1435 c.crop.getWidth(), 1436 c.crop.getHeight(), 1437 c.requested.w, c.requested.h, 1438 s.active.w, s.active.h, 1439 s.crop.left, 1440 s.crop.top, 1441 s.crop.right, 1442 s.crop.bottom, 1443 s.crop.getWidth(), 1444 s.crop.getHeight(), 1445 s.requested.w, s.requested.h); 1446 1447 // record the new size, form this point on, when the client request 1448 // a buffer, it'll get the new size. 1449 mSurfaceFlingerConsumer->setDefaultBufferSize( 1450 c.requested.w, c.requested.h); 1451 } 1452 1453 const bool resizePending = (c.requested.w != c.active.w) || 1454 (c.requested.h != c.active.h); 1455 if (!isFixedSize()) { 1456 if (resizePending && mSidebandStream == NULL) { 1457 // don't let Layer::doTransaction update the drawing state 1458 // if we have a pending resize, unless we are in fixed-size mode. 1459 // the drawing state will be updated only once we receive a buffer 1460 // with the correct size. 1461 // 1462 // in particular, we want to make sure the clip (which is part 1463 // of the geometry state) is latched together with the size but is 1464 // latched immediately when no resizing is involved. 1465 // 1466 // If a sideband stream is attached, however, we want to skip this 1467 // optimization so that transactions aren't missed when a buffer 1468 // never arrives 1469 1470 flags |= eDontUpdateGeometryState; 1471 } 1472 } 1473 1474 // always set active to requested, unless we're asked not to 1475 // this is used by Layer, which special cases resizes. 1476 if (flags & eDontUpdateGeometryState) { 1477 } else { 1478 Layer::State& editCurrentState(getCurrentState()); 1479 if (mFreezePositionUpdates) { 1480 float tx = c.active.transform.tx(); 1481 float ty = c.active.transform.ty(); 1482 c.active = c.requested; 1483 c.active.transform.set(tx, ty); 1484 editCurrentState.active = c.active; 1485 } else { 1486 editCurrentState.active = editCurrentState.requested; 1487 c.active = c.requested; 1488 } 1489 } 1490 1491 if (s.active != c.active) { 1492 // invalidate and recompute the visible regions if needed 1493 flags |= Layer::eVisibleRegion; 1494 } 1495 1496 if (c.sequence != s.sequence) { 1497 // invalidate and recompute the visible regions if needed 1498 flags |= eVisibleRegion; 1499 this->contentDirty = true; 1500 1501 // we may use linear filtering, if the matrix scales us 1502 const uint8_t type = c.active.transform.getType(); 1503 mNeedsFiltering = (!c.active.transform.preserveRects() || 1504 (type >= Transform::SCALE)); 1505 } 1506 1507 // If the layer is hidden, signal and clear out all local sync points so 1508 // that transactions for layers depending on this layer's frames becoming 1509 // visible are not blocked 1510 if (c.flags & layer_state_t::eLayerHidden) { 1511 Mutex::Autolock lock(mLocalSyncPointMutex); 1512 for (auto& point : mLocalSyncPoints) { 1513 point->setFrameAvailable(); 1514 } 1515 mLocalSyncPoints.clear(); 1516 } 1517 1518 // Commit the transaction 1519 commitTransaction(c); 1520 return flags; 1521} 1522 1523void Layer::commitTransaction(const State& stateToCommit) { 1524 mDrawingState = stateToCommit; 1525} 1526 1527uint32_t Layer::getTransactionFlags(uint32_t flags) { 1528 return android_atomic_and(~flags, &mTransactionFlags) & flags; 1529} 1530 1531uint32_t Layer::setTransactionFlags(uint32_t flags) { 1532 return android_atomic_or(flags, &mTransactionFlags); 1533} 1534 1535bool Layer::setPosition(float x, float y, bool immediate) { 1536 if (mCurrentState.requested.transform.tx() == x && mCurrentState.requested.transform.ty() == y) 1537 return false; 1538 mCurrentState.sequence++; 1539 1540 // We update the requested and active position simultaneously because 1541 // we want to apply the position portion of the transform matrix immediately, 1542 // but still delay scaling when resizing a SCALING_MODE_FREEZE layer. 1543 mCurrentState.requested.transform.set(x, y); 1544 if (immediate && !mFreezePositionUpdates) { 1545 mCurrentState.active.transform.set(x, y); 1546 } 1547 mFreezePositionUpdates = mFreezePositionUpdates || !immediate; 1548 1549 mCurrentState.modified = true; 1550 setTransactionFlags(eTransactionNeeded); 1551 return true; 1552} 1553 1554bool Layer::setLayer(uint32_t z) { 1555 if (mCurrentState.z == z) 1556 return false; 1557 mCurrentState.sequence++; 1558 mCurrentState.z = z; 1559 mCurrentState.modified = true; 1560 setTransactionFlags(eTransactionNeeded); 1561 return true; 1562} 1563bool Layer::setSize(uint32_t w, uint32_t h) { 1564 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 1565 return false; 1566 mCurrentState.requested.w = w; 1567 mCurrentState.requested.h = h; 1568 mCurrentState.modified = true; 1569 setTransactionFlags(eTransactionNeeded); 1570 return true; 1571} 1572#ifdef USE_HWC2 1573bool Layer::setAlpha(float alpha) { 1574#else 1575bool Layer::setAlpha(uint8_t alpha) { 1576#endif 1577 if (mCurrentState.alpha == alpha) 1578 return false; 1579 mCurrentState.sequence++; 1580 mCurrentState.alpha = alpha; 1581 mCurrentState.modified = true; 1582 setTransactionFlags(eTransactionNeeded); 1583 return true; 1584} 1585bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 1586 mCurrentState.sequence++; 1587 mCurrentState.requested.transform.set( 1588 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); 1589 mCurrentState.modified = true; 1590 setTransactionFlags(eTransactionNeeded); 1591 return true; 1592} 1593bool Layer::setTransparentRegionHint(const Region& transparent) { 1594 mCurrentState.requestedTransparentRegion = transparent; 1595 mCurrentState.modified = true; 1596 setTransactionFlags(eTransactionNeeded); 1597 return true; 1598} 1599bool Layer::setFlags(uint8_t flags, uint8_t mask) { 1600 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 1601 if (mCurrentState.flags == newFlags) 1602 return false; 1603 mCurrentState.sequence++; 1604 mCurrentState.flags = newFlags; 1605 mCurrentState.mask = mask; 1606 mCurrentState.modified = true; 1607 setTransactionFlags(eTransactionNeeded); 1608 return true; 1609} 1610 1611bool Layer::setCrop(const Rect& crop, bool immediate) { 1612 if (mCurrentState.crop == crop) 1613 return false; 1614 mCurrentState.sequence++; 1615 mCurrentState.requestedCrop = crop; 1616 if (immediate) { 1617 mCurrentState.crop = crop; 1618 } 1619 mCurrentState.modified = true; 1620 setTransactionFlags(eTransactionNeeded); 1621 return true; 1622} 1623bool Layer::setFinalCrop(const Rect& crop) { 1624 if (mCurrentState.finalCrop == crop) 1625 return false; 1626 mCurrentState.sequence++; 1627 mCurrentState.finalCrop = crop; 1628 mCurrentState.modified = true; 1629 setTransactionFlags(eTransactionNeeded); 1630 return true; 1631} 1632 1633bool Layer::setOverrideScalingMode(int32_t scalingMode) { 1634 if (scalingMode == mOverrideScalingMode) 1635 return false; 1636 mOverrideScalingMode = scalingMode; 1637 setTransactionFlags(eTransactionNeeded); 1638 return true; 1639} 1640 1641uint32_t Layer::getEffectiveScalingMode() const { 1642 if (mOverrideScalingMode >= 0) { 1643 return mOverrideScalingMode; 1644 } 1645 return mCurrentScalingMode; 1646} 1647 1648bool Layer::setLayerStack(uint32_t layerStack) { 1649 if (mCurrentState.layerStack == layerStack) 1650 return false; 1651 mCurrentState.sequence++; 1652 mCurrentState.layerStack = layerStack; 1653 mCurrentState.modified = true; 1654 setTransactionFlags(eTransactionNeeded); 1655 return true; 1656} 1657 1658void Layer::deferTransactionUntil(const sp<IBinder>& handle, 1659 uint64_t frameNumber) { 1660 mCurrentState.handle = handle; 1661 mCurrentState.frameNumber = frameNumber; 1662 // We don't set eTransactionNeeded, because just receiving a deferral 1663 // request without any other state updates shouldn't actually induce a delay 1664 mCurrentState.modified = true; 1665 pushPendingState(); 1666 mCurrentState.handle = nullptr; 1667 mCurrentState.frameNumber = 0; 1668 mCurrentState.modified = false; 1669} 1670 1671void Layer::useSurfaceDamage() { 1672 if (mFlinger->mForceFullDamage) { 1673 surfaceDamageRegion = Region::INVALID_REGION; 1674 } else { 1675 surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage(); 1676 } 1677} 1678 1679void Layer::useEmptyDamage() { 1680 surfaceDamageRegion.clear(); 1681} 1682 1683// ---------------------------------------------------------------------------- 1684// pageflip handling... 1685// ---------------------------------------------------------------------------- 1686 1687bool Layer::shouldPresentNow(const DispSync& dispSync) const { 1688 if (mSidebandStreamChanged || mAutoRefresh) { 1689 return true; 1690 } 1691 1692 Mutex::Autolock lock(mQueueItemLock); 1693 if (mQueueItems.empty()) { 1694 return false; 1695 } 1696 auto timestamp = mQueueItems[0].mTimestamp; 1697 nsecs_t expectedPresent = 1698 mSurfaceFlingerConsumer->computeExpectedPresent(dispSync); 1699 1700 // Ignore timestamps more than a second in the future 1701 bool isPlausible = timestamp < (expectedPresent + s2ns(1)); 1702 ALOGW_IF(!isPlausible, "[%s] Timestamp %" PRId64 " seems implausible " 1703 "relative to expectedPresent %" PRId64, mName.string(), timestamp, 1704 expectedPresent); 1705 1706 bool isDue = timestamp < expectedPresent; 1707 return isDue || !isPlausible; 1708} 1709 1710bool Layer::onPreComposition() { 1711 mRefreshPending = false; 1712 return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh; 1713} 1714 1715bool Layer::onPostComposition() { 1716 bool frameLatencyNeeded = mFrameLatencyNeeded; 1717 if (mFrameLatencyNeeded) { 1718 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 1719 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 1720 1721 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 1722 if (frameReadyFence->isValid()) { 1723 mFrameTracker.setFrameReadyFence(frameReadyFence); 1724 } else { 1725 // There was no fence for this frame, so assume that it was ready 1726 // to be presented at the desired present time. 1727 mFrameTracker.setFrameReadyTime(desiredPresentTime); 1728 } 1729 1730 const HWComposer& hwc = mFlinger->getHwComposer(); 1731#ifdef USE_HWC2 1732 sp<Fence> presentFence = hwc.getRetireFence(HWC_DISPLAY_PRIMARY); 1733#else 1734 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 1735#endif 1736 if (presentFence->isValid()) { 1737 mFrameTracker.setActualPresentFence(presentFence); 1738 } else { 1739 // The HWC doesn't support present fences, so use the refresh 1740 // timestamp instead. 1741 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 1742 mFrameTracker.setActualPresentTime(presentTime); 1743 } 1744 1745 mFrameTracker.advanceFrame(); 1746 mFrameLatencyNeeded = false; 1747 } 1748 return frameLatencyNeeded; 1749} 1750 1751#ifdef USE_HWC2 1752void Layer::releasePendingBuffer() { 1753 mSurfaceFlingerConsumer->releasePendingBuffer(); 1754} 1755#endif 1756 1757bool Layer::isVisible() const { 1758 const Layer::State& s(mDrawingState); 1759#ifdef USE_HWC2 1760 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha > 0.0f 1761 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1762#else 1763 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha 1764 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1765#endif 1766} 1767 1768Region Layer::latchBuffer(bool& recomputeVisibleRegions) 1769{ 1770 ATRACE_CALL(); 1771 1772 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { 1773 // mSidebandStreamChanged was true 1774 mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream(); 1775 if (mSidebandStream != NULL) { 1776 setTransactionFlags(eTransactionNeeded); 1777 mFlinger->setTransactionFlags(eTraversalNeeded); 1778 } 1779 recomputeVisibleRegions = true; 1780 1781 const State& s(getDrawingState()); 1782 return s.active.transform.transform(Region(Rect(s.active.w, s.active.h))); 1783 } 1784 1785 Region outDirtyRegion; 1786 if (mQueuedFrames > 0 || mAutoRefresh) { 1787 1788 // if we've already called updateTexImage() without going through 1789 // a composition step, we have to skip this layer at this point 1790 // because we cannot call updateTeximage() without a corresponding 1791 // compositionComplete() call. 1792 // we'll trigger an update in onPreComposition(). 1793 if (mRefreshPending) { 1794 return outDirtyRegion; 1795 } 1796 1797 // If the head buffer's acquire fence hasn't signaled yet, return and 1798 // try again later 1799 if (!headFenceHasSignaled()) { 1800 mFlinger->signalLayerUpdate(); 1801 return outDirtyRegion; 1802 } 1803 1804 // Capture the old state of the layer for comparisons later 1805 const State& s(getDrawingState()); 1806 const bool oldOpacity = isOpaque(s); 1807 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 1808 1809 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 1810 Layer::State& front; 1811 Layer::State& current; 1812 bool& recomputeVisibleRegions; 1813 bool stickyTransformSet; 1814 const char* name; 1815 int32_t overrideScalingMode; 1816 bool& freezePositionUpdates; 1817 1818 Reject(Layer::State& front, Layer::State& current, 1819 bool& recomputeVisibleRegions, bool stickySet, 1820 const char* name, 1821 int32_t overrideScalingMode, 1822 bool& freezePositionUpdates) 1823 : front(front), current(current), 1824 recomputeVisibleRegions(recomputeVisibleRegions), 1825 stickyTransformSet(stickySet), 1826 name(name), 1827 overrideScalingMode(overrideScalingMode), 1828 freezePositionUpdates(freezePositionUpdates) { 1829 } 1830 1831 virtual bool reject(const sp<GraphicBuffer>& buf, 1832 const BufferItem& item) { 1833 if (buf == NULL) { 1834 return false; 1835 } 1836 1837 uint32_t bufWidth = buf->getWidth(); 1838 uint32_t bufHeight = buf->getHeight(); 1839 1840 // check that we received a buffer of the right size 1841 // (Take the buffer's orientation into account) 1842 if (item.mTransform & Transform::ROT_90) { 1843 swap(bufWidth, bufHeight); 1844 } 1845 1846 int actualScalingMode = overrideScalingMode >= 0 ? 1847 overrideScalingMode : item.mScalingMode; 1848 bool isFixedSize = actualScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1849 if (front.active != front.requested) { 1850 1851 if (isFixedSize || 1852 (bufWidth == front.requested.w && 1853 bufHeight == front.requested.h)) 1854 { 1855 // Here we pretend the transaction happened by updating the 1856 // current and drawing states. Drawing state is only accessed 1857 // in this thread, no need to have it locked 1858 front.active = front.requested; 1859 1860 // We also need to update the current state so that 1861 // we don't end-up overwriting the drawing state with 1862 // this stale current state during the next transaction 1863 // 1864 // NOTE: We don't need to hold the transaction lock here 1865 // because State::active is only accessed from this thread. 1866 current.active = front.active; 1867 current.modified = true; 1868 1869 // recompute visible region 1870 recomputeVisibleRegions = true; 1871 } 1872 1873 ALOGD_IF(DEBUG_RESIZE, 1874 "[%s] latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 1875 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1876 " requested={ wh={%4u,%4u} }}\n", 1877 name, 1878 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 1879 front.active.w, front.active.h, 1880 front.crop.left, 1881 front.crop.top, 1882 front.crop.right, 1883 front.crop.bottom, 1884 front.crop.getWidth(), 1885 front.crop.getHeight(), 1886 front.requested.w, front.requested.h); 1887 } 1888 1889 if (!isFixedSize && !stickyTransformSet) { 1890 if (front.active.w != bufWidth || 1891 front.active.h != bufHeight) { 1892 // reject this buffer 1893 ALOGE("[%s] rejecting buffer: " 1894 "bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}", 1895 name, bufWidth, bufHeight, front.active.w, front.active.h); 1896 return true; 1897 } 1898 } 1899 1900 // if the transparent region has changed (this test is 1901 // conservative, but that's fine, worst case we're doing 1902 // a bit of extra work), we latch the new one and we 1903 // trigger a visible-region recompute. 1904 if (!front.activeTransparentRegion.isTriviallyEqual( 1905 front.requestedTransparentRegion)) { 1906 front.activeTransparentRegion = front.requestedTransparentRegion; 1907 1908 // We also need to update the current state so that 1909 // we don't end-up overwriting the drawing state with 1910 // this stale current state during the next transaction 1911 // 1912 // NOTE: We don't need to hold the transaction lock here 1913 // because State::active is only accessed from this thread. 1914 current.activeTransparentRegion = front.activeTransparentRegion; 1915 1916 // recompute visible region 1917 recomputeVisibleRegions = true; 1918 } 1919 1920 if (front.crop != front.requestedCrop) { 1921 front.crop = front.requestedCrop; 1922 current.crop = front.requestedCrop; 1923 recomputeVisibleRegions = true; 1924 } 1925 freezePositionUpdates = false; 1926 1927 return false; 1928 } 1929 }; 1930 1931 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 1932 getProducerStickyTransform() != 0, mName.string(), 1933 mOverrideScalingMode, mFreezePositionUpdates); 1934 1935 1936 // Check all of our local sync points to ensure that all transactions 1937 // which need to have been applied prior to the frame which is about to 1938 // be latched have signaled 1939 1940 auto headFrameNumber = getHeadFrameNumber(); 1941 bool matchingFramesFound = false; 1942 bool allTransactionsApplied = true; 1943 { 1944 Mutex::Autolock lock(mLocalSyncPointMutex); 1945 for (auto& point : mLocalSyncPoints) { 1946 if (point->getFrameNumber() > headFrameNumber) { 1947 break; 1948 } 1949 1950 matchingFramesFound = true; 1951 1952 if (!point->frameIsAvailable()) { 1953 // We haven't notified the remote layer that the frame for 1954 // this point is available yet. Notify it now, and then 1955 // abort this attempt to latch. 1956 point->setFrameAvailable(); 1957 allTransactionsApplied = false; 1958 break; 1959 } 1960 1961 allTransactionsApplied &= point->transactionIsApplied(); 1962 } 1963 } 1964 1965 if (matchingFramesFound && !allTransactionsApplied) { 1966 mFlinger->signalLayerUpdate(); 1967 return outDirtyRegion; 1968 } 1969 1970 // This boolean is used to make sure that SurfaceFlinger's shadow copy 1971 // of the buffer queue isn't modified when the buffer queue is returning 1972 // BufferItem's that weren't actually queued. This can happen in shared 1973 // buffer mode. 1974 bool queuedBuffer = false; 1975 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, 1976 mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer, 1977 mLastFrameNumberReceived); 1978 if (updateResult == BufferQueue::PRESENT_LATER) { 1979 // Producer doesn't want buffer to be displayed yet. Signal a 1980 // layer update so we check again at the next opportunity. 1981 mFlinger->signalLayerUpdate(); 1982 return outDirtyRegion; 1983 } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) { 1984 // If the buffer has been rejected, remove it from the shadow queue 1985 // and return early 1986 if (queuedBuffer) { 1987 Mutex::Autolock lock(mQueueItemLock); 1988 mQueueItems.removeAt(0); 1989 android_atomic_dec(&mQueuedFrames); 1990 } 1991 return outDirtyRegion; 1992 } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { 1993 // This can occur if something goes wrong when trying to create the 1994 // EGLImage for this buffer. If this happens, the buffer has already 1995 // been released, so we need to clean up the queue and bug out 1996 // early. 1997 if (queuedBuffer) { 1998 Mutex::Autolock lock(mQueueItemLock); 1999 mQueueItems.clear(); 2000 android_atomic_and(0, &mQueuedFrames); 2001 } 2002 2003 // Once we have hit this state, the shadow queue may no longer 2004 // correctly reflect the incoming BufferQueue's contents, so even if 2005 // updateTexImage starts working, the only safe course of action is 2006 // to continue to ignore updates. 2007 mUpdateTexImageFailed = true; 2008 2009 return outDirtyRegion; 2010 } 2011 2012 if (queuedBuffer) { 2013 // Autolock scope 2014 auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2015 2016 Mutex::Autolock lock(mQueueItemLock); 2017 2018 // Remove any stale buffers that have been dropped during 2019 // updateTexImage 2020 while (mQueueItems[0].mFrameNumber != currentFrameNumber) { 2021 mQueueItems.removeAt(0); 2022 android_atomic_dec(&mQueuedFrames); 2023 } 2024 2025 mQueueItems.removeAt(0); 2026 } 2027 2028 2029 // Decrement the queued-frames count. Signal another event if we 2030 // have more frames pending. 2031 if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) 2032 || mAutoRefresh) { 2033 mFlinger->signalLayerUpdate(); 2034 } 2035 2036 if (updateResult != NO_ERROR) { 2037 // something happened! 2038 recomputeVisibleRegions = true; 2039 return outDirtyRegion; 2040 } 2041 2042 // update the active buffer 2043 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 2044 if (mActiveBuffer == NULL) { 2045 // this can only happen if the very first buffer was rejected. 2046 return outDirtyRegion; 2047 } 2048 2049 mRefreshPending = true; 2050 mFrameLatencyNeeded = true; 2051 if (oldActiveBuffer == NULL) { 2052 // the first time we receive a buffer, we need to trigger a 2053 // geometry invalidation. 2054 recomputeVisibleRegions = true; 2055 } 2056 2057 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 2058 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 2059 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 2060 if ((crop != mCurrentCrop) || 2061 (transform != mCurrentTransform) || 2062 (scalingMode != mCurrentScalingMode)) 2063 { 2064 mCurrentCrop = crop; 2065 mCurrentTransform = transform; 2066 mCurrentScalingMode = scalingMode; 2067 recomputeVisibleRegions = true; 2068 } 2069 2070 if (oldActiveBuffer != NULL) { 2071 uint32_t bufWidth = mActiveBuffer->getWidth(); 2072 uint32_t bufHeight = mActiveBuffer->getHeight(); 2073 if (bufWidth != uint32_t(oldActiveBuffer->width) || 2074 bufHeight != uint32_t(oldActiveBuffer->height)) { 2075 recomputeVisibleRegions = true; 2076 } 2077 } 2078 2079 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 2080 if (oldOpacity != isOpaque(s)) { 2081 recomputeVisibleRegions = true; 2082 } 2083 2084 mCurrentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2085 2086 // Remove any sync points corresponding to the buffer which was just 2087 // latched 2088 { 2089 Mutex::Autolock lock(mLocalSyncPointMutex); 2090 auto point = mLocalSyncPoints.begin(); 2091 while (point != mLocalSyncPoints.end()) { 2092 if (!(*point)->frameIsAvailable() || 2093 !(*point)->transactionIsApplied()) { 2094 // This sync point must have been added since we started 2095 // latching. Don't drop it yet. 2096 ++point; 2097 continue; 2098 } 2099 2100 if ((*point)->getFrameNumber() <= mCurrentFrameNumber) { 2101 point = mLocalSyncPoints.erase(point); 2102 } else { 2103 ++point; 2104 } 2105 } 2106 } 2107 2108 // FIXME: postedRegion should be dirty & bounds 2109 Region dirtyRegion(Rect(s.active.w, s.active.h)); 2110 2111 // transform the dirty region to window-manager space 2112 outDirtyRegion = (s.active.transform.transform(dirtyRegion)); 2113 } 2114 return outDirtyRegion; 2115} 2116 2117uint32_t Layer::getEffectiveUsage(uint32_t usage) const 2118{ 2119 // TODO: should we do something special if mSecure is set? 2120 if (mProtectedByApp) { 2121 // need a hardware-protected path to external video sink 2122 usage |= GraphicBuffer::USAGE_PROTECTED; 2123 } 2124 if (mPotentialCursor) { 2125 usage |= GraphicBuffer::USAGE_CURSOR; 2126 } 2127 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 2128 return usage; 2129} 2130 2131void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 2132 uint32_t orientation = 0; 2133 if (!mFlinger->mDebugDisableTransformHint) { 2134 // The transform hint is used to improve performance, but we can 2135 // only have a single transform hint, it cannot 2136 // apply to all displays. 2137 const Transform& planeTransform(hw->getTransform()); 2138 orientation = planeTransform.getOrientation(); 2139 if (orientation & Transform::ROT_INVALID) { 2140 orientation = 0; 2141 } 2142 } 2143 mSurfaceFlingerConsumer->setTransformHint(orientation); 2144} 2145 2146// ---------------------------------------------------------------------------- 2147// debugging 2148// ---------------------------------------------------------------------------- 2149 2150void Layer::dump(String8& result, Colorizer& colorizer) const 2151{ 2152 const Layer::State& s(getDrawingState()); 2153 2154 colorizer.colorize(result, Colorizer::GREEN); 2155 result.appendFormat( 2156 "+ %s %p (%s)\n", 2157 getTypeId(), this, getName().string()); 2158 colorizer.reset(result); 2159 2160 s.activeTransparentRegion.dump(result, "transparentRegion"); 2161 visibleRegion.dump(result, "visibleRegion"); 2162 surfaceDamageRegion.dump(result, "surfaceDamageRegion"); 2163 sp<Client> client(mClientRef.promote()); 2164 2165 result.appendFormat( " " 2166 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), " 2167 "crop=(%4d,%4d,%4d,%4d), finalCrop=(%4d,%4d,%4d,%4d), " 2168 "isOpaque=%1d, invalidate=%1d, " 2169#ifdef USE_HWC2 2170 "alpha=%.3f, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2171#else 2172 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2173#endif 2174 " client=%p\n", 2175 s.layerStack, s.z, s.active.transform.tx(), s.active.transform.ty(), s.active.w, s.active.h, 2176 s.crop.left, s.crop.top, 2177 s.crop.right, s.crop.bottom, 2178 s.finalCrop.left, s.finalCrop.top, 2179 s.finalCrop.right, s.finalCrop.bottom, 2180 isOpaque(s), contentDirty, 2181 s.alpha, s.flags, 2182 s.active.transform[0][0], s.active.transform[0][1], 2183 s.active.transform[1][0], s.active.transform[1][1], 2184 client.get()); 2185 2186 sp<const GraphicBuffer> buf0(mActiveBuffer); 2187 uint32_t w0=0, h0=0, s0=0, f0=0; 2188 if (buf0 != 0) { 2189 w0 = buf0->getWidth(); 2190 h0 = buf0->getHeight(); 2191 s0 = buf0->getStride(); 2192 f0 = buf0->format; 2193 } 2194 result.appendFormat( 2195 " " 2196 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 2197 " queued-frames=%d, mRefreshPending=%d\n", 2198 mFormat, w0, h0, s0,f0, 2199 mQueuedFrames, mRefreshPending); 2200 2201 if (mSurfaceFlingerConsumer != 0) { 2202 mSurfaceFlingerConsumer->dump(result, " "); 2203 } 2204} 2205 2206void Layer::dumpFrameStats(String8& result) const { 2207 mFrameTracker.dumpStats(result); 2208} 2209 2210void Layer::clearFrameStats() { 2211 mFrameTracker.clearStats(); 2212} 2213 2214void Layer::logFrameStats() { 2215 mFrameTracker.logAndResetStats(mName); 2216} 2217 2218void Layer::getFrameStats(FrameStats* outStats) const { 2219 mFrameTracker.getStats(outStats); 2220} 2221 2222void Layer::getFenceData(String8* outName, uint64_t* outFrameNumber, 2223 bool* outIsGlesComposition, nsecs_t* outPostedTime, 2224 sp<Fence>* outAcquireFence, sp<Fence>* outPrevReleaseFence) const { 2225 *outName = mName; 2226 *outFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2227 2228#ifdef USE_HWC2 2229 *outIsGlesComposition = mHwcLayers.count(HWC_DISPLAY_PRIMARY) ? 2230 mHwcLayers.at(HWC_DISPLAY_PRIMARY).compositionType == 2231 HWC2::Composition::Client : true; 2232#else 2233 *outIsGlesComposition = mIsGlesComposition; 2234#endif 2235 *outPostedTime = mSurfaceFlingerConsumer->getTimestamp(); 2236 *outAcquireFence = mSurfaceFlingerConsumer->getCurrentFence(); 2237 *outPrevReleaseFence = mSurfaceFlingerConsumer->getPrevReleaseFence(); 2238} 2239 2240std::vector<OccupancyTracker::Segment> Layer::getOccupancyHistory( 2241 bool forceFlush) { 2242 std::vector<OccupancyTracker::Segment> history; 2243 status_t result = mSurfaceFlingerConsumer->getOccupancyHistory(forceFlush, 2244 &history); 2245 if (result != NO_ERROR) { 2246 ALOGW("[%s] Failed to obtain occupancy history (%d)", mName.string(), 2247 result); 2248 return {}; 2249 } 2250 return history; 2251} 2252 2253bool Layer::getTransformToDisplayInverse() const { 2254 return mSurfaceFlingerConsumer->getTransformToDisplayInverse(); 2255} 2256 2257// --------------------------------------------------------------------------- 2258 2259Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 2260 const sp<Layer>& layer) 2261 : mFlinger(flinger), mLayer(layer) { 2262} 2263 2264Layer::LayerCleaner::~LayerCleaner() { 2265 // destroy client resources 2266 mFlinger->onLayerDestroyed(mLayer); 2267} 2268 2269// --------------------------------------------------------------------------- 2270}; // namespace android 2271 2272#if defined(__gl_h_) 2273#error "don't include gl/gl.h in this file" 2274#endif 2275 2276#if defined(__gl2_h_) 2277#error "don't include gl2/gl2.h in this file" 2278#endif 2279