Layer.cpp revision e24da966b14e5b952ee11a7d13bb1539be2a5c8e
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 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 1094uint64_t Layer::getHeadFrameNumber() const { 1095 Mutex::Autolock lock(mQueueItemLock); 1096 if (!mQueueItems.empty()) { 1097 return mQueueItems[0].mFrameNumber; 1098 } else { 1099 return mCurrentFrameNumber; 1100 } 1101} 1102 1103bool Layer::addSyncPoint(const std::shared_ptr<SyncPoint>& point) { 1104 if (point->getFrameNumber() <= mCurrentFrameNumber) { 1105 // Don't bother with a SyncPoint, since we've already latched the 1106 // relevant frame 1107 return false; 1108 } 1109 1110 Mutex::Autolock lock(mLocalSyncPointMutex); 1111 mLocalSyncPoints.push_back(point); 1112 return true; 1113} 1114 1115void Layer::setFiltering(bool filtering) { 1116 mFiltering = filtering; 1117} 1118 1119bool Layer::getFiltering() const { 1120 return mFiltering; 1121} 1122 1123// As documented in libhardware header, formats in the range 1124// 0x100 - 0x1FF are specific to the HAL implementation, and 1125// are known to have no alpha channel 1126// TODO: move definition for device-specific range into 1127// hardware.h, instead of using hard-coded values here. 1128#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) 1129 1130bool Layer::getOpacityForFormat(uint32_t format) { 1131 if (HARDWARE_IS_DEVICE_FORMAT(format)) { 1132 return true; 1133 } 1134 switch (format) { 1135 case HAL_PIXEL_FORMAT_RGBA_8888: 1136 case HAL_PIXEL_FORMAT_BGRA_8888: 1137 return false; 1138 } 1139 // in all other case, we have no blending (also for unknown formats) 1140 return true; 1141} 1142 1143// ---------------------------------------------------------------------------- 1144// local state 1145// ---------------------------------------------------------------------------- 1146 1147static void boundPoint(vec2* point, const Rect& crop) { 1148 if (point->x < crop.left) { 1149 point->x = crop.left; 1150 } 1151 if (point->x > crop.right) { 1152 point->x = crop.right; 1153 } 1154 if (point->y < crop.top) { 1155 point->y = crop.top; 1156 } 1157 if (point->y > crop.bottom) { 1158 point->y = crop.bottom; 1159 } 1160} 1161 1162void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh, 1163 bool useIdentityTransform) const 1164{ 1165 const Layer::State& s(getDrawingState()); 1166 const Transform tr(hw->getTransform()); 1167 const uint32_t hw_h = hw->getHeight(); 1168 Rect win(s.active.w, s.active.h); 1169 if (!s.crop.isEmpty()) { 1170 win.intersect(s.crop, &win); 1171 } 1172 // subtract the transparent region and snap to the bounds 1173 win = reduce(win, s.activeTransparentRegion); 1174 1175 vec2 lt = vec2(win.left, win.top); 1176 vec2 lb = vec2(win.left, win.bottom); 1177 vec2 rb = vec2(win.right, win.bottom); 1178 vec2 rt = vec2(win.right, win.top); 1179 1180 if (!useIdentityTransform) { 1181 lt = s.active.transform.transform(lt); 1182 lb = s.active.transform.transform(lb); 1183 rb = s.active.transform.transform(rb); 1184 rt = s.active.transform.transform(rt); 1185 } 1186 1187 if (!s.finalCrop.isEmpty()) { 1188 boundPoint(<, s.finalCrop); 1189 boundPoint(&lb, s.finalCrop); 1190 boundPoint(&rb, s.finalCrop); 1191 boundPoint(&rt, s.finalCrop); 1192 } 1193 1194 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>()); 1195 position[0] = tr.transform(lt); 1196 position[1] = tr.transform(lb); 1197 position[2] = tr.transform(rb); 1198 position[3] = tr.transform(rt); 1199 for (size_t i=0 ; i<4 ; i++) { 1200 position[i].y = hw_h - position[i].y; 1201 } 1202} 1203 1204bool Layer::isOpaque(const Layer::State& s) const 1205{ 1206 // if we don't have a buffer yet, we're translucent regardless of the 1207 // layer's opaque flag. 1208 if (mActiveBuffer == 0) { 1209 return false; 1210 } 1211 1212 // if the layer has the opaque flag, then we're always opaque, 1213 // otherwise we use the current buffer's format. 1214 return ((s.flags & layer_state_t::eLayerOpaque) != 0) || mCurrentOpacity; 1215} 1216 1217bool Layer::isSecure() const 1218{ 1219 const Layer::State& s(mDrawingState); 1220 return (s.flags & layer_state_t::eLayerSecure); 1221} 1222 1223bool Layer::isProtected() const 1224{ 1225 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 1226 return (activeBuffer != 0) && 1227 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 1228} 1229 1230bool Layer::isFixedSize() const { 1231 return getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1232} 1233 1234bool Layer::isCropped() const { 1235 return !mCurrentCrop.isEmpty(); 1236} 1237 1238bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const { 1239 return mNeedsFiltering || hw->needsFiltering(); 1240} 1241 1242void Layer::setVisibleRegion(const Region& visibleRegion) { 1243 // always called from main thread 1244 this->visibleRegion = visibleRegion; 1245} 1246 1247void Layer::setCoveredRegion(const Region& coveredRegion) { 1248 // always called from main thread 1249 this->coveredRegion = coveredRegion; 1250} 1251 1252void Layer::setVisibleNonTransparentRegion(const Region& 1253 setVisibleNonTransparentRegion) { 1254 // always called from main thread 1255 this->visibleNonTransparentRegion = setVisibleNonTransparentRegion; 1256} 1257 1258// ---------------------------------------------------------------------------- 1259// transaction 1260// ---------------------------------------------------------------------------- 1261 1262void Layer::pushPendingState() { 1263 if (!mCurrentState.modified) { 1264 return; 1265 } 1266 1267 // If this transaction is waiting on the receipt of a frame, generate a sync 1268 // point and send it to the remote layer. 1269 if (mCurrentState.handle != nullptr) { 1270 sp<Handle> handle = static_cast<Handle*>(mCurrentState.handle.get()); 1271 sp<Layer> handleLayer = handle->owner.promote(); 1272 if (handleLayer == nullptr) { 1273 ALOGE("[%s] Unable to promote Layer handle", mName.string()); 1274 // If we can't promote the layer we are intended to wait on, 1275 // then it is expired or otherwise invalid. Allow this transaction 1276 // to be applied as per normal (no synchronization). 1277 mCurrentState.handle = nullptr; 1278 } else { 1279 auto syncPoint = std::make_shared<SyncPoint>( 1280 mCurrentState.frameNumber); 1281 if (handleLayer->addSyncPoint(syncPoint)) { 1282 mRemoteSyncPoints.push_back(std::move(syncPoint)); 1283 } else { 1284 // We already missed the frame we're supposed to synchronize 1285 // on, so go ahead and apply the state update 1286 mCurrentState.handle = nullptr; 1287 } 1288 } 1289 1290 // Wake us up to check if the frame has been received 1291 setTransactionFlags(eTransactionNeeded); 1292 } 1293 mPendingStates.push_back(mCurrentState); 1294} 1295 1296void Layer::popPendingState(State* stateToCommit) { 1297 auto oldFlags = stateToCommit->flags; 1298 *stateToCommit = mPendingStates[0]; 1299 stateToCommit->flags = (oldFlags & ~stateToCommit->mask) | 1300 (stateToCommit->flags & stateToCommit->mask); 1301 1302 mPendingStates.removeAt(0); 1303} 1304 1305bool Layer::applyPendingStates(State* stateToCommit) { 1306 bool stateUpdateAvailable = false; 1307 while (!mPendingStates.empty()) { 1308 if (mPendingStates[0].handle != nullptr) { 1309 if (mRemoteSyncPoints.empty()) { 1310 // If we don't have a sync point for this, apply it anyway. It 1311 // will be visually wrong, but it should keep us from getting 1312 // into too much trouble. 1313 ALOGE("[%s] No local sync point found", mName.string()); 1314 popPendingState(stateToCommit); 1315 stateUpdateAvailable = true; 1316 continue; 1317 } 1318 1319 if (mRemoteSyncPoints.front()->getFrameNumber() != 1320 mPendingStates[0].frameNumber) { 1321 ALOGE("[%s] Unexpected sync point frame number found", 1322 mName.string()); 1323 1324 // Signal our end of the sync point and then dispose of it 1325 mRemoteSyncPoints.front()->setTransactionApplied(); 1326 mRemoteSyncPoints.pop_front(); 1327 continue; 1328 } 1329 1330 if (mRemoteSyncPoints.front()->frameIsAvailable()) { 1331 // Apply the state update 1332 popPendingState(stateToCommit); 1333 stateUpdateAvailable = true; 1334 1335 // Signal our end of the sync point and then dispose of it 1336 mRemoteSyncPoints.front()->setTransactionApplied(); 1337 mRemoteSyncPoints.pop_front(); 1338 } else { 1339 break; 1340 } 1341 } else { 1342 popPendingState(stateToCommit); 1343 stateUpdateAvailable = true; 1344 } 1345 } 1346 1347 // If we still have pending updates, wake SurfaceFlinger back up and point 1348 // it at this layer so we can process them 1349 if (!mPendingStates.empty()) { 1350 setTransactionFlags(eTransactionNeeded); 1351 mFlinger->setTransactionFlags(eTraversalNeeded); 1352 } 1353 1354 mCurrentState.modified = false; 1355 return stateUpdateAvailable; 1356} 1357 1358void Layer::notifyAvailableFrames() { 1359 auto headFrameNumber = getHeadFrameNumber(); 1360 Mutex::Autolock lock(mLocalSyncPointMutex); 1361 for (auto& point : mLocalSyncPoints) { 1362 if (headFrameNumber >= point->getFrameNumber()) { 1363 point->setFrameAvailable(); 1364 } 1365 } 1366} 1367 1368uint32_t Layer::doTransaction(uint32_t flags) { 1369 ATRACE_CALL(); 1370 1371 pushPendingState(); 1372 Layer::State c = getCurrentState(); 1373 if (!applyPendingStates(&c)) { 1374 return 0; 1375 } 1376 1377 const Layer::State& s(getDrawingState()); 1378 1379 const bool sizeChanged = (c.requested.w != s.requested.w) || 1380 (c.requested.h != s.requested.h); 1381 1382 if (sizeChanged) { 1383 // the size changed, we need to ask our client to request a new buffer 1384 ALOGD_IF(DEBUG_RESIZE, 1385 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 1386 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1387 " requested={ wh={%4u,%4u} }}\n" 1388 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1389 " requested={ wh={%4u,%4u} }}\n", 1390 this, getName().string(), mCurrentTransform, 1391 getEffectiveScalingMode(), 1392 c.active.w, c.active.h, 1393 c.crop.left, 1394 c.crop.top, 1395 c.crop.right, 1396 c.crop.bottom, 1397 c.crop.getWidth(), 1398 c.crop.getHeight(), 1399 c.requested.w, c.requested.h, 1400 s.active.w, s.active.h, 1401 s.crop.left, 1402 s.crop.top, 1403 s.crop.right, 1404 s.crop.bottom, 1405 s.crop.getWidth(), 1406 s.crop.getHeight(), 1407 s.requested.w, s.requested.h); 1408 1409 // record the new size, form this point on, when the client request 1410 // a buffer, it'll get the new size. 1411 mSurfaceFlingerConsumer->setDefaultBufferSize( 1412 c.requested.w, c.requested.h); 1413 } 1414 1415 const bool resizePending = (c.requested.w != c.active.w) || 1416 (c.requested.h != c.active.h); 1417 if (!isFixedSize()) { 1418 if (resizePending && mSidebandStream == NULL) { 1419 // don't let Layer::doTransaction update the drawing state 1420 // if we have a pending resize, unless we are in fixed-size mode. 1421 // the drawing state will be updated only once we receive a buffer 1422 // with the correct size. 1423 // 1424 // in particular, we want to make sure the clip (which is part 1425 // of the geometry state) is latched together with the size but is 1426 // latched immediately when no resizing is involved. 1427 // 1428 // If a sideband stream is attached, however, we want to skip this 1429 // optimization so that transactions aren't missed when a buffer 1430 // never arrives 1431 1432 flags |= eDontUpdateGeometryState; 1433 } 1434 } 1435 1436 // always set active to requested, unless we're asked not to 1437 // this is used by Layer, which special cases resizes. 1438 if (flags & eDontUpdateGeometryState) { 1439 } else { 1440 Layer::State& editCurrentState(getCurrentState()); 1441 if (mFreezePositionUpdates) { 1442 float tx = c.active.transform.tx(); 1443 float ty = c.active.transform.ty(); 1444 c.active = c.requested; 1445 c.active.transform.set(tx, ty); 1446 editCurrentState.active = c.active; 1447 } else { 1448 editCurrentState.active = editCurrentState.requested; 1449 c.active = c.requested; 1450 } 1451 } 1452 1453 if (s.active != c.active) { 1454 // invalidate and recompute the visible regions if needed 1455 flags |= Layer::eVisibleRegion; 1456 } 1457 1458 if (c.sequence != s.sequence) { 1459 // invalidate and recompute the visible regions if needed 1460 flags |= eVisibleRegion; 1461 this->contentDirty = true; 1462 1463 // we may use linear filtering, if the matrix scales us 1464 const uint8_t type = c.active.transform.getType(); 1465 mNeedsFiltering = (!c.active.transform.preserveRects() || 1466 (type >= Transform::SCALE)); 1467 } 1468 1469 // If the layer is hidden, signal and clear out all local sync points so 1470 // that transactions for layers depending on this layer's frames becoming 1471 // visible are not blocked 1472 if (c.flags & layer_state_t::eLayerHidden) { 1473 Mutex::Autolock lock(mLocalSyncPointMutex); 1474 for (auto& point : mLocalSyncPoints) { 1475 point->setFrameAvailable(); 1476 } 1477 mLocalSyncPoints.clear(); 1478 } 1479 1480 // Commit the transaction 1481 commitTransaction(c); 1482 return flags; 1483} 1484 1485void Layer::commitTransaction(const State& stateToCommit) { 1486 mDrawingState = stateToCommit; 1487} 1488 1489uint32_t Layer::getTransactionFlags(uint32_t flags) { 1490 return android_atomic_and(~flags, &mTransactionFlags) & flags; 1491} 1492 1493uint32_t Layer::setTransactionFlags(uint32_t flags) { 1494 return android_atomic_or(flags, &mTransactionFlags); 1495} 1496 1497bool Layer::setPosition(float x, float y, bool immediate) { 1498 if (mCurrentState.requested.transform.tx() == x && mCurrentState.requested.transform.ty() == y) 1499 return false; 1500 mCurrentState.sequence++; 1501 1502 // We update the requested and active position simultaneously because 1503 // we want to apply the position portion of the transform matrix immediately, 1504 // but still delay scaling when resizing a SCALING_MODE_FREEZE layer. 1505 mCurrentState.requested.transform.set(x, y); 1506 if (immediate && !mFreezePositionUpdates) { 1507 mCurrentState.active.transform.set(x, y); 1508 } 1509 mFreezePositionUpdates = mFreezePositionUpdates || !immediate; 1510 1511 mCurrentState.modified = true; 1512 setTransactionFlags(eTransactionNeeded); 1513 return true; 1514} 1515 1516bool Layer::setLayer(uint32_t z) { 1517 if (mCurrentState.z == z) 1518 return false; 1519 mCurrentState.sequence++; 1520 mCurrentState.z = z; 1521 mCurrentState.modified = true; 1522 setTransactionFlags(eTransactionNeeded); 1523 return true; 1524} 1525bool Layer::setSize(uint32_t w, uint32_t h) { 1526 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 1527 return false; 1528 mCurrentState.requested.w = w; 1529 mCurrentState.requested.h = h; 1530 mCurrentState.modified = true; 1531 setTransactionFlags(eTransactionNeeded); 1532 return true; 1533} 1534#ifdef USE_HWC2 1535bool Layer::setAlpha(float alpha) { 1536#else 1537bool Layer::setAlpha(uint8_t alpha) { 1538#endif 1539 if (mCurrentState.alpha == alpha) 1540 return false; 1541 mCurrentState.sequence++; 1542 mCurrentState.alpha = alpha; 1543 mCurrentState.modified = true; 1544 setTransactionFlags(eTransactionNeeded); 1545 return true; 1546} 1547bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 1548 mCurrentState.sequence++; 1549 mCurrentState.requested.transform.set( 1550 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); 1551 mCurrentState.modified = true; 1552 setTransactionFlags(eTransactionNeeded); 1553 return true; 1554} 1555bool Layer::setTransparentRegionHint(const Region& transparent) { 1556 mCurrentState.requestedTransparentRegion = transparent; 1557 mCurrentState.modified = true; 1558 setTransactionFlags(eTransactionNeeded); 1559 return true; 1560} 1561bool Layer::setFlags(uint8_t flags, uint8_t mask) { 1562 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 1563 if (mCurrentState.flags == newFlags) 1564 return false; 1565 mCurrentState.sequence++; 1566 mCurrentState.flags = newFlags; 1567 mCurrentState.mask = mask; 1568 mCurrentState.modified = true; 1569 setTransactionFlags(eTransactionNeeded); 1570 return true; 1571} 1572bool Layer::setCrop(const Rect& crop) { 1573 if (mCurrentState.crop == crop) 1574 return false; 1575 mCurrentState.sequence++; 1576 mCurrentState.crop = crop; 1577 mCurrentState.modified = true; 1578 setTransactionFlags(eTransactionNeeded); 1579 return true; 1580} 1581bool Layer::setFinalCrop(const Rect& crop) { 1582 if (mCurrentState.finalCrop == crop) 1583 return false; 1584 mCurrentState.sequence++; 1585 mCurrentState.finalCrop = crop; 1586 mCurrentState.modified = true; 1587 setTransactionFlags(eTransactionNeeded); 1588 return true; 1589} 1590 1591bool Layer::setOverrideScalingMode(int32_t scalingMode) { 1592 if (scalingMode == mOverrideScalingMode) 1593 return false; 1594 mOverrideScalingMode = scalingMode; 1595 setTransactionFlags(eTransactionNeeded); 1596 return true; 1597} 1598 1599uint32_t Layer::getEffectiveScalingMode() const { 1600 if (mOverrideScalingMode >= 0) { 1601 return mOverrideScalingMode; 1602 } 1603 return mCurrentScalingMode; 1604} 1605 1606bool Layer::setLayerStack(uint32_t layerStack) { 1607 if (mCurrentState.layerStack == layerStack) 1608 return false; 1609 mCurrentState.sequence++; 1610 mCurrentState.layerStack = layerStack; 1611 mCurrentState.modified = true; 1612 setTransactionFlags(eTransactionNeeded); 1613 return true; 1614} 1615 1616void Layer::deferTransactionUntil(const sp<IBinder>& handle, 1617 uint64_t frameNumber) { 1618 mCurrentState.handle = handle; 1619 mCurrentState.frameNumber = frameNumber; 1620 // We don't set eTransactionNeeded, because just receiving a deferral 1621 // request without any other state updates shouldn't actually induce a delay 1622 mCurrentState.modified = true; 1623 pushPendingState(); 1624 mCurrentState.handle = nullptr; 1625 mCurrentState.frameNumber = 0; 1626 mCurrentState.modified = false; 1627} 1628 1629void Layer::useSurfaceDamage() { 1630 if (mFlinger->mForceFullDamage) { 1631 surfaceDamageRegion = Region::INVALID_REGION; 1632 } else { 1633 surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage(); 1634 } 1635} 1636 1637void Layer::useEmptyDamage() { 1638 surfaceDamageRegion.clear(); 1639} 1640 1641// ---------------------------------------------------------------------------- 1642// pageflip handling... 1643// ---------------------------------------------------------------------------- 1644 1645bool Layer::shouldPresentNow(const DispSync& dispSync) const { 1646 if (mSidebandStreamChanged || mAutoRefresh) { 1647 return true; 1648 } 1649 1650 Mutex::Autolock lock(mQueueItemLock); 1651 if (mQueueItems.empty()) { 1652 return false; 1653 } 1654 auto timestamp = mQueueItems[0].mTimestamp; 1655 nsecs_t expectedPresent = 1656 mSurfaceFlingerConsumer->computeExpectedPresent(dispSync); 1657 1658 // Ignore timestamps more than a second in the future 1659 bool isPlausible = timestamp < (expectedPresent + s2ns(1)); 1660 ALOGW_IF(!isPlausible, "[%s] Timestamp %" PRId64 " seems implausible " 1661 "relative to expectedPresent %" PRId64, mName.string(), timestamp, 1662 expectedPresent); 1663 1664 bool isDue = timestamp < expectedPresent; 1665 return isDue || !isPlausible; 1666} 1667 1668bool Layer::onPreComposition() { 1669 mRefreshPending = false; 1670 return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh; 1671} 1672 1673bool Layer::onPostComposition() { 1674 bool frameLatencyNeeded = mFrameLatencyNeeded; 1675 if (mFrameLatencyNeeded) { 1676 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 1677 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 1678 1679 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 1680 if (frameReadyFence->isValid()) { 1681 mFrameTracker.setFrameReadyFence(frameReadyFence); 1682 } else { 1683 // There was no fence for this frame, so assume that it was ready 1684 // to be presented at the desired present time. 1685 mFrameTracker.setFrameReadyTime(desiredPresentTime); 1686 } 1687 1688 const HWComposer& hwc = mFlinger->getHwComposer(); 1689#ifdef USE_HWC2 1690 sp<Fence> presentFence = hwc.getRetireFence(HWC_DISPLAY_PRIMARY); 1691#else 1692 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 1693#endif 1694 if (presentFence->isValid()) { 1695 mFrameTracker.setActualPresentFence(presentFence); 1696 } else { 1697 // The HWC doesn't support present fences, so use the refresh 1698 // timestamp instead. 1699 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 1700 mFrameTracker.setActualPresentTime(presentTime); 1701 } 1702 1703 mFrameTracker.advanceFrame(); 1704 mFrameLatencyNeeded = false; 1705 } 1706 return frameLatencyNeeded; 1707} 1708 1709#ifdef USE_HWC2 1710void Layer::releasePendingBuffer() { 1711 mSurfaceFlingerConsumer->releasePendingBuffer(); 1712} 1713#endif 1714 1715bool Layer::isVisible() const { 1716 const Layer::State& s(mDrawingState); 1717#ifdef USE_HWC2 1718 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha > 0.0f 1719 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1720#else 1721 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha 1722 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1723#endif 1724} 1725 1726Region Layer::latchBuffer(bool& recomputeVisibleRegions) 1727{ 1728 ATRACE_CALL(); 1729 1730 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { 1731 // mSidebandStreamChanged was true 1732 mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream(); 1733 if (mSidebandStream != NULL) { 1734 setTransactionFlags(eTransactionNeeded); 1735 mFlinger->setTransactionFlags(eTraversalNeeded); 1736 } 1737 recomputeVisibleRegions = true; 1738 1739 const State& s(getDrawingState()); 1740 return s.active.transform.transform(Region(Rect(s.active.w, s.active.h))); 1741 } 1742 1743 Region outDirtyRegion; 1744 if (mQueuedFrames > 0 || mAutoRefresh) { 1745 1746 // if we've already called updateTexImage() without going through 1747 // a composition step, we have to skip this layer at this point 1748 // because we cannot call updateTeximage() without a corresponding 1749 // compositionComplete() call. 1750 // we'll trigger an update in onPreComposition(). 1751 if (mRefreshPending) { 1752 return outDirtyRegion; 1753 } 1754 1755 // Capture the old state of the layer for comparisons later 1756 const State& s(getDrawingState()); 1757 const bool oldOpacity = isOpaque(s); 1758 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 1759 1760 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 1761 Layer::State& front; 1762 Layer::State& current; 1763 bool& recomputeVisibleRegions; 1764 bool stickyTransformSet; 1765 const char* name; 1766 int32_t overrideScalingMode; 1767 1768 Reject(Layer::State& front, Layer::State& current, 1769 bool& recomputeVisibleRegions, bool stickySet, 1770 const char* name, 1771 int32_t overrideScalingMode) 1772 : front(front), current(current), 1773 recomputeVisibleRegions(recomputeVisibleRegions), 1774 stickyTransformSet(stickySet), 1775 name(name), 1776 overrideScalingMode(overrideScalingMode) { 1777 } 1778 1779 virtual bool reject(const sp<GraphicBuffer>& buf, 1780 const BufferItem& item) { 1781 if (buf == NULL) { 1782 return false; 1783 } 1784 1785 uint32_t bufWidth = buf->getWidth(); 1786 uint32_t bufHeight = buf->getHeight(); 1787 1788 // check that we received a buffer of the right size 1789 // (Take the buffer's orientation into account) 1790 if (item.mTransform & Transform::ROT_90) { 1791 swap(bufWidth, bufHeight); 1792 } 1793 1794 int actualScalingMode = overrideScalingMode >= 0 ? 1795 overrideScalingMode : item.mScalingMode; 1796 bool isFixedSize = actualScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1797 if (front.active != front.requested) { 1798 1799 if (isFixedSize || 1800 (bufWidth == front.requested.w && 1801 bufHeight == front.requested.h)) 1802 { 1803 // Here we pretend the transaction happened by updating the 1804 // current and drawing states. Drawing state is only accessed 1805 // in this thread, no need to have it locked 1806 front.active = front.requested; 1807 1808 // We also need to update the current state so that 1809 // we don't end-up overwriting the drawing state with 1810 // this stale current state during the next transaction 1811 // 1812 // NOTE: We don't need to hold the transaction lock here 1813 // because State::active is only accessed from this thread. 1814 current.active = front.active; 1815 current.modified = true; 1816 1817 // recompute visible region 1818 recomputeVisibleRegions = true; 1819 } 1820 1821 ALOGD_IF(DEBUG_RESIZE, 1822 "[%s] latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 1823 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1824 " requested={ wh={%4u,%4u} }}\n", 1825 name, 1826 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 1827 front.active.w, front.active.h, 1828 front.crop.left, 1829 front.crop.top, 1830 front.crop.right, 1831 front.crop.bottom, 1832 front.crop.getWidth(), 1833 front.crop.getHeight(), 1834 front.requested.w, front.requested.h); 1835 } 1836 1837 if (!isFixedSize && !stickyTransformSet) { 1838 if (front.active.w != bufWidth || 1839 front.active.h != bufHeight) { 1840 // reject this buffer 1841 ALOGE("[%s] rejecting buffer: " 1842 "bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}", 1843 name, bufWidth, bufHeight, front.active.w, front.active.h); 1844 return true; 1845 } 1846 } 1847 1848 // if the transparent region has changed (this test is 1849 // conservative, but that's fine, worst case we're doing 1850 // a bit of extra work), we latch the new one and we 1851 // trigger a visible-region recompute. 1852 if (!front.activeTransparentRegion.isTriviallyEqual( 1853 front.requestedTransparentRegion)) { 1854 front.activeTransparentRegion = front.requestedTransparentRegion; 1855 1856 // We also need to update the current state so that 1857 // we don't end-up overwriting the drawing state with 1858 // this stale current state during the next transaction 1859 // 1860 // NOTE: We don't need to hold the transaction lock here 1861 // because State::active is only accessed from this thread. 1862 current.activeTransparentRegion = front.activeTransparentRegion; 1863 1864 // recompute visible region 1865 recomputeVisibleRegions = true; 1866 } 1867 1868 return false; 1869 } 1870 }; 1871 1872 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 1873 getProducerStickyTransform() != 0, mName.string(), 1874 mOverrideScalingMode); 1875 1876 1877 // Check all of our local sync points to ensure that all transactions 1878 // which need to have been applied prior to the frame which is about to 1879 // be latched have signaled 1880 1881 auto headFrameNumber = getHeadFrameNumber(); 1882 bool matchingFramesFound = false; 1883 bool allTransactionsApplied = true; 1884 { 1885 Mutex::Autolock lock(mLocalSyncPointMutex); 1886 for (auto& point : mLocalSyncPoints) { 1887 if (point->getFrameNumber() > headFrameNumber) { 1888 break; 1889 } 1890 1891 matchingFramesFound = true; 1892 1893 if (!point->frameIsAvailable()) { 1894 // We haven't notified the remote layer that the frame for 1895 // this point is available yet. Notify it now, and then 1896 // abort this attempt to latch. 1897 point->setFrameAvailable(); 1898 allTransactionsApplied = false; 1899 break; 1900 } 1901 1902 allTransactionsApplied &= point->transactionIsApplied(); 1903 } 1904 } 1905 1906 if (matchingFramesFound && !allTransactionsApplied) { 1907 mFlinger->signalLayerUpdate(); 1908 return outDirtyRegion; 1909 } 1910 1911 // This boolean is used to make sure that SurfaceFlinger's shadow copy 1912 // of the buffer queue isn't modified when the buffer queue is returning 1913 // BufferItem's that weren't actually queued. This can happen in shared 1914 // buffer mode. 1915 bool queuedBuffer = false; 1916 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, 1917 mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer, 1918 mLastFrameNumberReceived); 1919 if (updateResult == BufferQueue::PRESENT_LATER) { 1920 // Producer doesn't want buffer to be displayed yet. Signal a 1921 // layer update so we check again at the next opportunity. 1922 mFlinger->signalLayerUpdate(); 1923 return outDirtyRegion; 1924 } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) { 1925 // If the buffer has been rejected, remove it from the shadow queue 1926 // and return early 1927 if (queuedBuffer) { 1928 Mutex::Autolock lock(mQueueItemLock); 1929 mQueueItems.removeAt(0); 1930 android_atomic_dec(&mQueuedFrames); 1931 } 1932 return outDirtyRegion; 1933 } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { 1934 // This can occur if something goes wrong when trying to create the 1935 // EGLImage for this buffer. If this happens, the buffer has already 1936 // been released, so we need to clean up the queue and bug out 1937 // early. 1938 if (queuedBuffer) { 1939 Mutex::Autolock lock(mQueueItemLock); 1940 mQueueItems.clear(); 1941 android_atomic_and(0, &mQueuedFrames); 1942 } 1943 1944 // Once we have hit this state, the shadow queue may no longer 1945 // correctly reflect the incoming BufferQueue's contents, so even if 1946 // updateTexImage starts working, the only safe course of action is 1947 // to continue to ignore updates. 1948 mUpdateTexImageFailed = true; 1949 1950 return outDirtyRegion; 1951 } 1952 1953 if (queuedBuffer) { 1954 // Autolock scope 1955 auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 1956 1957 Mutex::Autolock lock(mQueueItemLock); 1958 1959 // Remove any stale buffers that have been dropped during 1960 // updateTexImage 1961 while (mQueueItems[0].mFrameNumber != currentFrameNumber) { 1962 mQueueItems.removeAt(0); 1963 android_atomic_dec(&mQueuedFrames); 1964 } 1965 1966 mQueueItems.removeAt(0); 1967 } 1968 1969 1970 // Decrement the queued-frames count. Signal another event if we 1971 // have more frames pending. 1972 if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) 1973 || mAutoRefresh) { 1974 mFlinger->signalLayerUpdate(); 1975 } 1976 1977 if (updateResult != NO_ERROR) { 1978 // something happened! 1979 recomputeVisibleRegions = true; 1980 return outDirtyRegion; 1981 } 1982 1983 // update the active buffer 1984 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 1985 if (mActiveBuffer == NULL) { 1986 // this can only happen if the very first buffer was rejected. 1987 return outDirtyRegion; 1988 } 1989 1990 mRefreshPending = true; 1991 mFrameLatencyNeeded = true; 1992 if (oldActiveBuffer == NULL) { 1993 // the first time we receive a buffer, we need to trigger a 1994 // geometry invalidation. 1995 recomputeVisibleRegions = true; 1996 } 1997 1998 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 1999 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 2000 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 2001 if ((crop != mCurrentCrop) || 2002 (transform != mCurrentTransform) || 2003 (scalingMode != mCurrentScalingMode)) 2004 { 2005 mCurrentCrop = crop; 2006 mCurrentTransform = transform; 2007 mCurrentScalingMode = scalingMode; 2008 recomputeVisibleRegions = true; 2009 } 2010 2011 if (oldActiveBuffer != NULL) { 2012 uint32_t bufWidth = mActiveBuffer->getWidth(); 2013 uint32_t bufHeight = mActiveBuffer->getHeight(); 2014 if (bufWidth != uint32_t(oldActiveBuffer->width) || 2015 bufHeight != uint32_t(oldActiveBuffer->height)) { 2016 recomputeVisibleRegions = true; 2017 mFreezePositionUpdates = false; 2018 } 2019 } 2020 2021 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 2022 if (oldOpacity != isOpaque(s)) { 2023 recomputeVisibleRegions = true; 2024 } 2025 2026 mCurrentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2027 2028 // Remove any sync points corresponding to the buffer which was just 2029 // latched 2030 { 2031 Mutex::Autolock lock(mLocalSyncPointMutex); 2032 auto point = mLocalSyncPoints.begin(); 2033 while (point != mLocalSyncPoints.end()) { 2034 if (!(*point)->frameIsAvailable() || 2035 !(*point)->transactionIsApplied()) { 2036 // This sync point must have been added since we started 2037 // latching. Don't drop it yet. 2038 ++point; 2039 continue; 2040 } 2041 2042 if ((*point)->getFrameNumber() <= mCurrentFrameNumber) { 2043 point = mLocalSyncPoints.erase(point); 2044 } else { 2045 ++point; 2046 } 2047 } 2048 } 2049 2050 // FIXME: postedRegion should be dirty & bounds 2051 Region dirtyRegion(Rect(s.active.w, s.active.h)); 2052 2053 // transform the dirty region to window-manager space 2054 outDirtyRegion = (s.active.transform.transform(dirtyRegion)); 2055 } 2056 return outDirtyRegion; 2057} 2058 2059uint32_t Layer::getEffectiveUsage(uint32_t usage) const 2060{ 2061 // TODO: should we do something special if mSecure is set? 2062 if (mProtectedByApp) { 2063 // need a hardware-protected path to external video sink 2064 usage |= GraphicBuffer::USAGE_PROTECTED; 2065 } 2066 if (mPotentialCursor) { 2067 usage |= GraphicBuffer::USAGE_CURSOR; 2068 } 2069 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 2070 return usage; 2071} 2072 2073void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 2074 uint32_t orientation = 0; 2075 if (!mFlinger->mDebugDisableTransformHint) { 2076 // The transform hint is used to improve performance, but we can 2077 // only have a single transform hint, it cannot 2078 // apply to all displays. 2079 const Transform& planeTransform(hw->getTransform()); 2080 orientation = planeTransform.getOrientation(); 2081 if (orientation & Transform::ROT_INVALID) { 2082 orientation = 0; 2083 } 2084 } 2085 mSurfaceFlingerConsumer->setTransformHint(orientation); 2086} 2087 2088// ---------------------------------------------------------------------------- 2089// debugging 2090// ---------------------------------------------------------------------------- 2091 2092void Layer::dump(String8& result, Colorizer& colorizer) const 2093{ 2094 const Layer::State& s(getDrawingState()); 2095 2096 colorizer.colorize(result, Colorizer::GREEN); 2097 result.appendFormat( 2098 "+ %s %p (%s)\n", 2099 getTypeId(), this, getName().string()); 2100 colorizer.reset(result); 2101 2102 s.activeTransparentRegion.dump(result, "transparentRegion"); 2103 visibleRegion.dump(result, "visibleRegion"); 2104 surfaceDamageRegion.dump(result, "surfaceDamageRegion"); 2105 sp<Client> client(mClientRef.promote()); 2106 2107 result.appendFormat( " " 2108 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), " 2109 "crop=(%4d,%4d,%4d,%4d), finalCrop=(%4d,%4d,%4d,%4d), " 2110 "isOpaque=%1d, invalidate=%1d, " 2111#ifdef USE_HWC2 2112 "alpha=%.3f, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2113#else 2114 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2115#endif 2116 " client=%p\n", 2117 s.layerStack, s.z, s.active.transform.tx(), s.active.transform.ty(), s.active.w, s.active.h, 2118 s.crop.left, s.crop.top, 2119 s.crop.right, s.crop.bottom, 2120 s.finalCrop.left, s.finalCrop.top, 2121 s.finalCrop.right, s.finalCrop.bottom, 2122 isOpaque(s), contentDirty, 2123 s.alpha, s.flags, 2124 s.active.transform[0][0], s.active.transform[0][1], 2125 s.active.transform[1][0], s.active.transform[1][1], 2126 client.get()); 2127 2128 sp<const GraphicBuffer> buf0(mActiveBuffer); 2129 uint32_t w0=0, h0=0, s0=0, f0=0; 2130 if (buf0 != 0) { 2131 w0 = buf0->getWidth(); 2132 h0 = buf0->getHeight(); 2133 s0 = buf0->getStride(); 2134 f0 = buf0->format; 2135 } 2136 result.appendFormat( 2137 " " 2138 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 2139 " queued-frames=%d, mRefreshPending=%d\n", 2140 mFormat, w0, h0, s0,f0, 2141 mQueuedFrames, mRefreshPending); 2142 2143 if (mSurfaceFlingerConsumer != 0) { 2144 mSurfaceFlingerConsumer->dump(result, " "); 2145 } 2146} 2147 2148void Layer::dumpFrameStats(String8& result) const { 2149 mFrameTracker.dumpStats(result); 2150} 2151 2152void Layer::clearFrameStats() { 2153 mFrameTracker.clearStats(); 2154} 2155 2156void Layer::logFrameStats() { 2157 mFrameTracker.logAndResetStats(mName); 2158} 2159 2160void Layer::getFrameStats(FrameStats* outStats) const { 2161 mFrameTracker.getStats(outStats); 2162} 2163 2164void Layer::getFenceData(String8* outName, uint64_t* outFrameNumber, 2165 bool* outIsGlesComposition, nsecs_t* outPostedTime, 2166 sp<Fence>* outAcquireFence, sp<Fence>* outPrevReleaseFence) const { 2167 *outName = mName; 2168 *outFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2169 2170#ifdef USE_HWC2 2171 *outIsGlesComposition = mHwcLayers.count(HWC_DISPLAY_PRIMARY) ? 2172 mHwcLayers.at(HWC_DISPLAY_PRIMARY).compositionType == 2173 HWC2::Composition::Client : true; 2174#else 2175 *outIsGlesComposition = mIsGlesComposition; 2176#endif 2177 *outPostedTime = mSurfaceFlingerConsumer->getTimestamp(); 2178 *outAcquireFence = mSurfaceFlingerConsumer->getCurrentFence(); 2179 *outPrevReleaseFence = mSurfaceFlingerConsumer->getPrevReleaseFence(); 2180} 2181 2182std::vector<OccupancyTracker::Segment> Layer::getOccupancyHistory( 2183 bool forceFlush) { 2184 std::vector<OccupancyTracker::Segment> history; 2185 status_t result = mSurfaceFlingerConsumer->getOccupancyHistory(forceFlush, 2186 &history); 2187 if (result != NO_ERROR) { 2188 ALOGW("[%s] Failed to obtain occupancy history (%d)", mName.string(), 2189 result); 2190 return {}; 2191 } 2192 return history; 2193} 2194 2195// --------------------------------------------------------------------------- 2196 2197Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 2198 const sp<Layer>& layer) 2199 : mFlinger(flinger), mLayer(layer) { 2200} 2201 2202Layer::LayerCleaner::~LayerCleaner() { 2203 // destroy client resources 2204 mFlinger->onLayerDestroyed(mLayer); 2205} 2206 2207// --------------------------------------------------------------------------- 2208}; // namespace android 2209 2210#if defined(__gl_h_) 2211#error "don't include gl/gl.h in this file" 2212#endif 2213 2214#if defined(__gl2_h_) 2215#error "don't include gl2/gl2.h in this file" 2216#endif 2217