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