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