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