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