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