Layer.cpp revision dd03e70fd620a7a305c1a271583e0da07d6c1ac4
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, true); 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<IBinder> strongBinder = mCurrentState.handle.promote(); 1317 sp<Handle> handle = nullptr; 1318 sp<Layer> handleLayer = nullptr; 1319 if (strongBinder != nullptr) { 1320 handle = static_cast<Handle*>(strongBinder.get()); 1321 handleLayer = handle->owner.promote(); 1322 } 1323 if (strongBinder == nullptr || handleLayer == nullptr) { 1324 ALOGE("[%s] Unable to promote Layer handle", mName.string()); 1325 // If we can't promote the layer we are intended to wait on, 1326 // then it is expired or otherwise invalid. Allow this transaction 1327 // to be applied as per normal (no synchronization). 1328 mCurrentState.handle = nullptr; 1329 } else { 1330 auto syncPoint = std::make_shared<SyncPoint>( 1331 mCurrentState.frameNumber); 1332 if (handleLayer->addSyncPoint(syncPoint)) { 1333 mRemoteSyncPoints.push_back(std::move(syncPoint)); 1334 } else { 1335 // We already missed the frame we're supposed to synchronize 1336 // on, so go ahead and apply the state update 1337 mCurrentState.handle = nullptr; 1338 } 1339 } 1340 1341 // Wake us up to check if the frame has been received 1342 setTransactionFlags(eTransactionNeeded); 1343 } 1344 mPendingStates.push_back(mCurrentState); 1345} 1346 1347void Layer::popPendingState(State* stateToCommit) { 1348 auto oldFlags = stateToCommit->flags; 1349 *stateToCommit = mPendingStates[0]; 1350 stateToCommit->flags = (oldFlags & ~stateToCommit->mask) | 1351 (stateToCommit->flags & stateToCommit->mask); 1352 1353 mPendingStates.removeAt(0); 1354} 1355 1356bool Layer::applyPendingStates(State* stateToCommit) { 1357 bool stateUpdateAvailable = false; 1358 while (!mPendingStates.empty()) { 1359 if (mPendingStates[0].handle != nullptr) { 1360 if (mRemoteSyncPoints.empty()) { 1361 // If we don't have a sync point for this, apply it anyway. It 1362 // will be visually wrong, but it should keep us from getting 1363 // into too much trouble. 1364 ALOGE("[%s] No local sync point found", mName.string()); 1365 popPendingState(stateToCommit); 1366 stateUpdateAvailable = true; 1367 continue; 1368 } 1369 1370 if (mRemoteSyncPoints.front()->getFrameNumber() != 1371 mPendingStates[0].frameNumber) { 1372 ALOGE("[%s] Unexpected sync point frame number found", 1373 mName.string()); 1374 1375 // Signal our end of the sync point and then dispose of it 1376 mRemoteSyncPoints.front()->setTransactionApplied(); 1377 mRemoteSyncPoints.pop_front(); 1378 continue; 1379 } 1380 1381 if (mRemoteSyncPoints.front()->frameIsAvailable()) { 1382 // Apply the state update 1383 popPendingState(stateToCommit); 1384 stateUpdateAvailable = true; 1385 1386 // Signal our end of the sync point and then dispose of it 1387 mRemoteSyncPoints.front()->setTransactionApplied(); 1388 mRemoteSyncPoints.pop_front(); 1389 } else { 1390 break; 1391 } 1392 } else { 1393 popPendingState(stateToCommit); 1394 stateUpdateAvailable = true; 1395 } 1396 } 1397 1398 // If we still have pending updates, wake SurfaceFlinger back up and point 1399 // it at this layer so we can process them 1400 if (!mPendingStates.empty()) { 1401 setTransactionFlags(eTransactionNeeded); 1402 mFlinger->setTransactionFlags(eTraversalNeeded); 1403 } 1404 1405 mCurrentState.modified = false; 1406 return stateUpdateAvailable; 1407} 1408 1409void Layer::notifyAvailableFrames() { 1410 auto headFrameNumber = getHeadFrameNumber(); 1411 bool headFenceSignaled = headFenceHasSignaled(); 1412 Mutex::Autolock lock(mLocalSyncPointMutex); 1413 for (auto& point : mLocalSyncPoints) { 1414 if (headFrameNumber >= point->getFrameNumber() && headFenceSignaled) { 1415 point->setFrameAvailable(); 1416 } 1417 } 1418} 1419 1420uint32_t Layer::doTransaction(uint32_t flags) { 1421 ATRACE_CALL(); 1422 1423 pushPendingState(); 1424 Layer::State c = getCurrentState(); 1425 if (!applyPendingStates(&c)) { 1426 return 0; 1427 } 1428 1429 const Layer::State& s(getDrawingState()); 1430 1431 const bool sizeChanged = (c.requested.w != s.requested.w) || 1432 (c.requested.h != s.requested.h); 1433 1434 if (sizeChanged) { 1435 // the size changed, we need to ask our client to request a new buffer 1436 ALOGD_IF(DEBUG_RESIZE, 1437 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 1438 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1439 " requested={ wh={%4u,%4u} }}\n" 1440 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1441 " requested={ wh={%4u,%4u} }}\n", 1442 this, getName().string(), mCurrentTransform, 1443 getEffectiveScalingMode(), 1444 c.active.w, c.active.h, 1445 c.crop.left, 1446 c.crop.top, 1447 c.crop.right, 1448 c.crop.bottom, 1449 c.crop.getWidth(), 1450 c.crop.getHeight(), 1451 c.requested.w, c.requested.h, 1452 s.active.w, s.active.h, 1453 s.crop.left, 1454 s.crop.top, 1455 s.crop.right, 1456 s.crop.bottom, 1457 s.crop.getWidth(), 1458 s.crop.getHeight(), 1459 s.requested.w, s.requested.h); 1460 1461 // record the new size, form this point on, when the client request 1462 // a buffer, it'll get the new size. 1463 mSurfaceFlingerConsumer->setDefaultBufferSize( 1464 c.requested.w, c.requested.h); 1465 } 1466 1467 const bool resizePending = (c.requested.w != c.active.w) || 1468 (c.requested.h != c.active.h); 1469 if (!isFixedSize()) { 1470 if (resizePending && mSidebandStream == NULL) { 1471 // don't let Layer::doTransaction update the drawing state 1472 // if we have a pending resize, unless we are in fixed-size mode. 1473 // the drawing state will be updated only once we receive a buffer 1474 // with the correct size. 1475 // 1476 // in particular, we want to make sure the clip (which is part 1477 // of the geometry state) is latched together with the size but is 1478 // latched immediately when no resizing is involved. 1479 // 1480 // If a sideband stream is attached, however, we want to skip this 1481 // optimization so that transactions aren't missed when a buffer 1482 // never arrives 1483 1484 flags |= eDontUpdateGeometryState; 1485 } 1486 } 1487 1488 // always set active to requested, unless we're asked not to 1489 // this is used by Layer, which special cases resizes. 1490 if (flags & eDontUpdateGeometryState) { 1491 } else { 1492 Layer::State& editCurrentState(getCurrentState()); 1493 if (mFreezePositionUpdates) { 1494 float tx = c.active.transform.tx(); 1495 float ty = c.active.transform.ty(); 1496 c.active = c.requested; 1497 c.active.transform.set(tx, ty); 1498 editCurrentState.active = c.active; 1499 } else { 1500 editCurrentState.active = editCurrentState.requested; 1501 c.active = c.requested; 1502 } 1503 } 1504 1505 if (s.active != c.active) { 1506 // invalidate and recompute the visible regions if needed 1507 flags |= Layer::eVisibleRegion; 1508 } 1509 1510 if (c.sequence != s.sequence) { 1511 // invalidate and recompute the visible regions if needed 1512 flags |= eVisibleRegion; 1513 this->contentDirty = true; 1514 1515 // we may use linear filtering, if the matrix scales us 1516 const uint8_t type = c.active.transform.getType(); 1517 mNeedsFiltering = (!c.active.transform.preserveRects() || 1518 (type >= Transform::SCALE)); 1519 } 1520 1521 // If the layer is hidden, signal and clear out all local sync points so 1522 // that transactions for layers depending on this layer's frames becoming 1523 // visible are not blocked 1524 if (c.flags & layer_state_t::eLayerHidden) { 1525 Mutex::Autolock lock(mLocalSyncPointMutex); 1526 for (auto& point : mLocalSyncPoints) { 1527 point->setFrameAvailable(); 1528 } 1529 mLocalSyncPoints.clear(); 1530 } 1531 1532 // Commit the transaction 1533 commitTransaction(c); 1534 return flags; 1535} 1536 1537void Layer::commitTransaction(const State& stateToCommit) { 1538 mDrawingState = stateToCommit; 1539} 1540 1541uint32_t Layer::getTransactionFlags(uint32_t flags) { 1542 return android_atomic_and(~flags, &mTransactionFlags) & flags; 1543} 1544 1545uint32_t Layer::setTransactionFlags(uint32_t flags) { 1546 return android_atomic_or(flags, &mTransactionFlags); 1547} 1548 1549bool Layer::setPosition(float x, float y, bool immediate) { 1550 if (mCurrentState.requested.transform.tx() == x && mCurrentState.requested.transform.ty() == y) 1551 return false; 1552 mCurrentState.sequence++; 1553 1554 // We update the requested and active position simultaneously because 1555 // we want to apply the position portion of the transform matrix immediately, 1556 // but still delay scaling when resizing a SCALING_MODE_FREEZE layer. 1557 mCurrentState.requested.transform.set(x, y); 1558 if (immediate && !mFreezePositionUpdates) { 1559 mCurrentState.active.transform.set(x, y); 1560 } 1561 mFreezePositionUpdates = mFreezePositionUpdates || !immediate; 1562 1563 mCurrentState.modified = true; 1564 setTransactionFlags(eTransactionNeeded); 1565 return true; 1566} 1567 1568bool Layer::setLayer(uint32_t z) { 1569 if (mCurrentState.z == z) 1570 return false; 1571 mCurrentState.sequence++; 1572 mCurrentState.z = z; 1573 mCurrentState.modified = true; 1574 setTransactionFlags(eTransactionNeeded); 1575 return true; 1576} 1577bool Layer::setSize(uint32_t w, uint32_t h) { 1578 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 1579 return false; 1580 mCurrentState.requested.w = w; 1581 mCurrentState.requested.h = h; 1582 mCurrentState.modified = true; 1583 setTransactionFlags(eTransactionNeeded); 1584 return true; 1585} 1586#ifdef USE_HWC2 1587bool Layer::setAlpha(float alpha) { 1588#else 1589bool Layer::setAlpha(uint8_t alpha) { 1590#endif 1591 if (mCurrentState.alpha == alpha) 1592 return false; 1593 mCurrentState.sequence++; 1594 mCurrentState.alpha = alpha; 1595 mCurrentState.modified = true; 1596 setTransactionFlags(eTransactionNeeded); 1597 return true; 1598} 1599bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 1600 mCurrentState.sequence++; 1601 mCurrentState.requested.transform.set( 1602 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); 1603 mCurrentState.modified = true; 1604 setTransactionFlags(eTransactionNeeded); 1605 return true; 1606} 1607bool Layer::setTransparentRegionHint(const Region& transparent) { 1608 mCurrentState.requestedTransparentRegion = transparent; 1609 mCurrentState.modified = true; 1610 setTransactionFlags(eTransactionNeeded); 1611 return true; 1612} 1613bool Layer::setFlags(uint8_t flags, uint8_t mask) { 1614 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 1615 if (mCurrentState.flags == newFlags) 1616 return false; 1617 mCurrentState.sequence++; 1618 mCurrentState.flags = newFlags; 1619 mCurrentState.mask = mask; 1620 mCurrentState.modified = true; 1621 setTransactionFlags(eTransactionNeeded); 1622 return true; 1623} 1624 1625bool Layer::setCrop(const Rect& crop, bool immediate) { 1626 if (mCurrentState.crop == crop) 1627 return false; 1628 mCurrentState.sequence++; 1629 mCurrentState.requestedCrop = crop; 1630 if (immediate) { 1631 mCurrentState.crop = crop; 1632 } 1633 mCurrentState.modified = true; 1634 setTransactionFlags(eTransactionNeeded); 1635 return true; 1636} 1637bool Layer::setFinalCrop(const Rect& crop) { 1638 if (mCurrentState.finalCrop == crop) 1639 return false; 1640 mCurrentState.sequence++; 1641 mCurrentState.finalCrop = crop; 1642 mCurrentState.modified = true; 1643 setTransactionFlags(eTransactionNeeded); 1644 return true; 1645} 1646 1647bool Layer::setOverrideScalingMode(int32_t scalingMode) { 1648 if (scalingMode == mOverrideScalingMode) 1649 return false; 1650 mOverrideScalingMode = scalingMode; 1651 setTransactionFlags(eTransactionNeeded); 1652 return true; 1653} 1654 1655uint32_t Layer::getEffectiveScalingMode() const { 1656 if (mOverrideScalingMode >= 0) { 1657 return mOverrideScalingMode; 1658 } 1659 return mCurrentScalingMode; 1660} 1661 1662bool Layer::setLayerStack(uint32_t layerStack) { 1663 if (mCurrentState.layerStack == layerStack) 1664 return false; 1665 mCurrentState.sequence++; 1666 mCurrentState.layerStack = layerStack; 1667 mCurrentState.modified = true; 1668 setTransactionFlags(eTransactionNeeded); 1669 return true; 1670} 1671 1672void Layer::deferTransactionUntil(const sp<IBinder>& handle, 1673 uint64_t frameNumber) { 1674 mCurrentState.handle = handle; 1675 mCurrentState.frameNumber = frameNumber; 1676 // We don't set eTransactionNeeded, because just receiving a deferral 1677 // request without any other state updates shouldn't actually induce a delay 1678 mCurrentState.modified = true; 1679 pushPendingState(); 1680 mCurrentState.handle = nullptr; 1681 mCurrentState.frameNumber = 0; 1682 mCurrentState.modified = false; 1683} 1684 1685void Layer::useSurfaceDamage() { 1686 if (mFlinger->mForceFullDamage) { 1687 surfaceDamageRegion = Region::INVALID_REGION; 1688 } else { 1689 surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage(); 1690 } 1691} 1692 1693void Layer::useEmptyDamage() { 1694 surfaceDamageRegion.clear(); 1695} 1696 1697// ---------------------------------------------------------------------------- 1698// pageflip handling... 1699// ---------------------------------------------------------------------------- 1700 1701bool Layer::shouldPresentNow(const DispSync& dispSync) const { 1702 if (mSidebandStreamChanged || mAutoRefresh) { 1703 return true; 1704 } 1705 1706 Mutex::Autolock lock(mQueueItemLock); 1707 if (mQueueItems.empty()) { 1708 return false; 1709 } 1710 auto timestamp = mQueueItems[0].mTimestamp; 1711 nsecs_t expectedPresent = 1712 mSurfaceFlingerConsumer->computeExpectedPresent(dispSync); 1713 1714 // Ignore timestamps more than a second in the future 1715 bool isPlausible = timestamp < (expectedPresent + s2ns(1)); 1716 ALOGW_IF(!isPlausible, "[%s] Timestamp %" PRId64 " seems implausible " 1717 "relative to expectedPresent %" PRId64, mName.string(), timestamp, 1718 expectedPresent); 1719 1720 bool isDue = timestamp < expectedPresent; 1721 return isDue || !isPlausible; 1722} 1723 1724bool Layer::onPreComposition() { 1725 mRefreshPending = false; 1726 return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh; 1727} 1728 1729bool Layer::onPostComposition() { 1730 bool frameLatencyNeeded = mFrameLatencyNeeded; 1731 if (mFrameLatencyNeeded) { 1732 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 1733 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 1734 1735 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 1736 if (frameReadyFence->isValid()) { 1737 mFrameTracker.setFrameReadyFence(frameReadyFence); 1738 } else { 1739 // There was no fence for this frame, so assume that it was ready 1740 // to be presented at the desired present time. 1741 mFrameTracker.setFrameReadyTime(desiredPresentTime); 1742 } 1743 1744 const HWComposer& hwc = mFlinger->getHwComposer(); 1745#ifdef USE_HWC2 1746 sp<Fence> presentFence = hwc.getRetireFence(HWC_DISPLAY_PRIMARY); 1747#else 1748 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 1749#endif 1750 if (presentFence->isValid()) { 1751 mFrameTracker.setActualPresentFence(presentFence); 1752 } else { 1753 // The HWC doesn't support present fences, so use the refresh 1754 // timestamp instead. 1755 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 1756 mFrameTracker.setActualPresentTime(presentTime); 1757 } 1758 1759 mFrameTracker.advanceFrame(); 1760 mFrameLatencyNeeded = false; 1761 } 1762 return frameLatencyNeeded; 1763} 1764 1765#ifdef USE_HWC2 1766void Layer::releasePendingBuffer() { 1767 mSurfaceFlingerConsumer->releasePendingBuffer(); 1768} 1769#endif 1770 1771bool Layer::isVisible() const { 1772 const Layer::State& s(mDrawingState); 1773#ifdef USE_HWC2 1774 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha > 0.0f 1775 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1776#else 1777 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha 1778 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1779#endif 1780} 1781 1782Region Layer::latchBuffer(bool& recomputeVisibleRegions) 1783{ 1784 ATRACE_CALL(); 1785 1786 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { 1787 // mSidebandStreamChanged was true 1788 mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream(); 1789 if (mSidebandStream != NULL) { 1790 setTransactionFlags(eTransactionNeeded); 1791 mFlinger->setTransactionFlags(eTraversalNeeded); 1792 } 1793 recomputeVisibleRegions = true; 1794 1795 const State& s(getDrawingState()); 1796 return s.active.transform.transform(Region(Rect(s.active.w, s.active.h))); 1797 } 1798 1799 Region outDirtyRegion; 1800 if (mQueuedFrames > 0 || mAutoRefresh) { 1801 1802 // if we've already called updateTexImage() without going through 1803 // a composition step, we have to skip this layer at this point 1804 // because we cannot call updateTeximage() without a corresponding 1805 // compositionComplete() call. 1806 // we'll trigger an update in onPreComposition(). 1807 if (mRefreshPending) { 1808 return outDirtyRegion; 1809 } 1810 1811 // If the head buffer's acquire fence hasn't signaled yet, return and 1812 // try again later 1813 if (!headFenceHasSignaled()) { 1814 mFlinger->signalLayerUpdate(); 1815 return outDirtyRegion; 1816 } 1817 1818 // Capture the old state of the layer for comparisons later 1819 const State& s(getDrawingState()); 1820 const bool oldOpacity = isOpaque(s); 1821 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 1822 1823 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 1824 Layer::State& front; 1825 Layer::State& current; 1826 bool& recomputeVisibleRegions; 1827 bool stickyTransformSet; 1828 const char* name; 1829 int32_t overrideScalingMode; 1830 bool& freezePositionUpdates; 1831 1832 Reject(Layer::State& front, Layer::State& current, 1833 bool& recomputeVisibleRegions, bool stickySet, 1834 const char* name, 1835 int32_t overrideScalingMode, 1836 bool& freezePositionUpdates) 1837 : front(front), current(current), 1838 recomputeVisibleRegions(recomputeVisibleRegions), 1839 stickyTransformSet(stickySet), 1840 name(name), 1841 overrideScalingMode(overrideScalingMode), 1842 freezePositionUpdates(freezePositionUpdates) { 1843 } 1844 1845 virtual bool reject(const sp<GraphicBuffer>& buf, 1846 const BufferItem& item) { 1847 if (buf == NULL) { 1848 return false; 1849 } 1850 1851 uint32_t bufWidth = buf->getWidth(); 1852 uint32_t bufHeight = buf->getHeight(); 1853 1854 // check that we received a buffer of the right size 1855 // (Take the buffer's orientation into account) 1856 if (item.mTransform & Transform::ROT_90) { 1857 swap(bufWidth, bufHeight); 1858 } 1859 1860 int actualScalingMode = overrideScalingMode >= 0 ? 1861 overrideScalingMode : item.mScalingMode; 1862 bool isFixedSize = actualScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1863 if (front.active != front.requested) { 1864 1865 if (isFixedSize || 1866 (bufWidth == front.requested.w && 1867 bufHeight == front.requested.h)) 1868 { 1869 // Here we pretend the transaction happened by updating the 1870 // current and drawing states. Drawing state is only accessed 1871 // in this thread, no need to have it locked 1872 front.active = front.requested; 1873 1874 // We also need to update the current state so that 1875 // we don't end-up overwriting the drawing state with 1876 // this stale current state during the next transaction 1877 // 1878 // NOTE: We don't need to hold the transaction lock here 1879 // because State::active is only accessed from this thread. 1880 current.active = front.active; 1881 current.modified = true; 1882 1883 // recompute visible region 1884 recomputeVisibleRegions = true; 1885 } 1886 1887 ALOGD_IF(DEBUG_RESIZE, 1888 "[%s] latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 1889 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1890 " requested={ wh={%4u,%4u} }}\n", 1891 name, 1892 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 1893 front.active.w, front.active.h, 1894 front.crop.left, 1895 front.crop.top, 1896 front.crop.right, 1897 front.crop.bottom, 1898 front.crop.getWidth(), 1899 front.crop.getHeight(), 1900 front.requested.w, front.requested.h); 1901 } 1902 1903 if (!isFixedSize && !stickyTransformSet) { 1904 if (front.active.w != bufWidth || 1905 front.active.h != bufHeight) { 1906 // reject this buffer 1907 ALOGE("[%s] rejecting buffer: " 1908 "bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}", 1909 name, bufWidth, bufHeight, front.active.w, front.active.h); 1910 return true; 1911 } 1912 } 1913 1914 // if the transparent region has changed (this test is 1915 // conservative, but that's fine, worst case we're doing 1916 // a bit of extra work), we latch the new one and we 1917 // trigger a visible-region recompute. 1918 if (!front.activeTransparentRegion.isTriviallyEqual( 1919 front.requestedTransparentRegion)) { 1920 front.activeTransparentRegion = front.requestedTransparentRegion; 1921 1922 // We also need to update the current state so that 1923 // we don't end-up overwriting the drawing state with 1924 // this stale current state during the next transaction 1925 // 1926 // NOTE: We don't need to hold the transaction lock here 1927 // because State::active is only accessed from this thread. 1928 current.activeTransparentRegion = front.activeTransparentRegion; 1929 1930 // recompute visible region 1931 recomputeVisibleRegions = true; 1932 } 1933 1934 if (front.crop != front.requestedCrop) { 1935 front.crop = front.requestedCrop; 1936 current.crop = front.requestedCrop; 1937 recomputeVisibleRegions = true; 1938 } 1939 freezePositionUpdates = false; 1940 1941 return false; 1942 } 1943 }; 1944 1945 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 1946 getProducerStickyTransform() != 0, mName.string(), 1947 mOverrideScalingMode, mFreezePositionUpdates); 1948 1949 1950 // Check all of our local sync points to ensure that all transactions 1951 // which need to have been applied prior to the frame which is about to 1952 // be latched have signaled 1953 1954 auto headFrameNumber = getHeadFrameNumber(); 1955 bool matchingFramesFound = false; 1956 bool allTransactionsApplied = true; 1957 { 1958 Mutex::Autolock lock(mLocalSyncPointMutex); 1959 for (auto& point : mLocalSyncPoints) { 1960 if (point->getFrameNumber() > headFrameNumber) { 1961 break; 1962 } 1963 1964 matchingFramesFound = true; 1965 1966 if (!point->frameIsAvailable()) { 1967 // We haven't notified the remote layer that the frame for 1968 // this point is available yet. Notify it now, and then 1969 // abort this attempt to latch. 1970 point->setFrameAvailable(); 1971 allTransactionsApplied = false; 1972 break; 1973 } 1974 1975 allTransactionsApplied &= point->transactionIsApplied(); 1976 } 1977 } 1978 1979 if (matchingFramesFound && !allTransactionsApplied) { 1980 mFlinger->signalLayerUpdate(); 1981 return outDirtyRegion; 1982 } 1983 1984 // This boolean is used to make sure that SurfaceFlinger's shadow copy 1985 // of the buffer queue isn't modified when the buffer queue is returning 1986 // BufferItem's that weren't actually queued. This can happen in shared 1987 // buffer mode. 1988 bool queuedBuffer = false; 1989 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, 1990 mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer, 1991 mLastFrameNumberReceived); 1992 if (updateResult == BufferQueue::PRESENT_LATER) { 1993 // Producer doesn't want buffer to be displayed yet. Signal a 1994 // layer update so we check again at the next opportunity. 1995 mFlinger->signalLayerUpdate(); 1996 return outDirtyRegion; 1997 } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) { 1998 // If the buffer has been rejected, remove it from the shadow queue 1999 // and return early 2000 if (queuedBuffer) { 2001 Mutex::Autolock lock(mQueueItemLock); 2002 mQueueItems.removeAt(0); 2003 android_atomic_dec(&mQueuedFrames); 2004 } 2005 return outDirtyRegion; 2006 } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { 2007 // This can occur if something goes wrong when trying to create the 2008 // EGLImage for this buffer. If this happens, the buffer has already 2009 // been released, so we need to clean up the queue and bug out 2010 // early. 2011 if (queuedBuffer) { 2012 Mutex::Autolock lock(mQueueItemLock); 2013 mQueueItems.clear(); 2014 android_atomic_and(0, &mQueuedFrames); 2015 } 2016 2017 // Once we have hit this state, the shadow queue may no longer 2018 // correctly reflect the incoming BufferQueue's contents, so even if 2019 // updateTexImage starts working, the only safe course of action is 2020 // to continue to ignore updates. 2021 mUpdateTexImageFailed = true; 2022 2023 return outDirtyRegion; 2024 } 2025 2026 if (queuedBuffer) { 2027 // Autolock scope 2028 auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2029 2030 Mutex::Autolock lock(mQueueItemLock); 2031 2032 // Remove any stale buffers that have been dropped during 2033 // updateTexImage 2034 while (mQueueItems[0].mFrameNumber != currentFrameNumber) { 2035 mQueueItems.removeAt(0); 2036 android_atomic_dec(&mQueuedFrames); 2037 } 2038 2039 mQueueItems.removeAt(0); 2040 } 2041 2042 2043 // Decrement the queued-frames count. Signal another event if we 2044 // have more frames pending. 2045 if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) 2046 || mAutoRefresh) { 2047 mFlinger->signalLayerUpdate(); 2048 } 2049 2050 if (updateResult != NO_ERROR) { 2051 // something happened! 2052 recomputeVisibleRegions = true; 2053 return outDirtyRegion; 2054 } 2055 2056 // update the active buffer 2057 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 2058 if (mActiveBuffer == NULL) { 2059 // this can only happen if the very first buffer was rejected. 2060 return outDirtyRegion; 2061 } 2062 2063 mRefreshPending = true; 2064 mFrameLatencyNeeded = true; 2065 if (oldActiveBuffer == NULL) { 2066 // the first time we receive a buffer, we need to trigger a 2067 // geometry invalidation. 2068 recomputeVisibleRegions = true; 2069 } 2070 2071 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 2072 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 2073 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 2074 if ((crop != mCurrentCrop) || 2075 (transform != mCurrentTransform) || 2076 (scalingMode != mCurrentScalingMode)) 2077 { 2078 mCurrentCrop = crop; 2079 mCurrentTransform = transform; 2080 mCurrentScalingMode = scalingMode; 2081 recomputeVisibleRegions = true; 2082 } 2083 2084 if (oldActiveBuffer != NULL) { 2085 uint32_t bufWidth = mActiveBuffer->getWidth(); 2086 uint32_t bufHeight = mActiveBuffer->getHeight(); 2087 if (bufWidth != uint32_t(oldActiveBuffer->width) || 2088 bufHeight != uint32_t(oldActiveBuffer->height)) { 2089 recomputeVisibleRegions = true; 2090 } 2091 } 2092 2093 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 2094 if (oldOpacity != isOpaque(s)) { 2095 recomputeVisibleRegions = true; 2096 } 2097 2098 mCurrentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2099 2100 // Remove any sync points corresponding to the buffer which was just 2101 // latched 2102 { 2103 Mutex::Autolock lock(mLocalSyncPointMutex); 2104 auto point = mLocalSyncPoints.begin(); 2105 while (point != mLocalSyncPoints.end()) { 2106 if (!(*point)->frameIsAvailable() || 2107 !(*point)->transactionIsApplied()) { 2108 // This sync point must have been added since we started 2109 // latching. Don't drop it yet. 2110 ++point; 2111 continue; 2112 } 2113 2114 if ((*point)->getFrameNumber() <= mCurrentFrameNumber) { 2115 point = mLocalSyncPoints.erase(point); 2116 } else { 2117 ++point; 2118 } 2119 } 2120 } 2121 2122 // FIXME: postedRegion should be dirty & bounds 2123 Region dirtyRegion(Rect(s.active.w, s.active.h)); 2124 2125 // transform the dirty region to window-manager space 2126 outDirtyRegion = (s.active.transform.transform(dirtyRegion)); 2127 } 2128 return outDirtyRegion; 2129} 2130 2131uint32_t Layer::getEffectiveUsage(uint32_t usage) const 2132{ 2133 // TODO: should we do something special if mSecure is set? 2134 if (mProtectedByApp) { 2135 // need a hardware-protected path to external video sink 2136 usage |= GraphicBuffer::USAGE_PROTECTED; 2137 } 2138 if (mPotentialCursor) { 2139 usage |= GraphicBuffer::USAGE_CURSOR; 2140 } 2141 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 2142 return usage; 2143} 2144 2145void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 2146 uint32_t orientation = 0; 2147 if (!mFlinger->mDebugDisableTransformHint) { 2148 // The transform hint is used to improve performance, but we can 2149 // only have a single transform hint, it cannot 2150 // apply to all displays. 2151 const Transform& planeTransform(hw->getTransform()); 2152 orientation = planeTransform.getOrientation(); 2153 if (orientation & Transform::ROT_INVALID) { 2154 orientation = 0; 2155 } 2156 } 2157 mSurfaceFlingerConsumer->setTransformHint(orientation); 2158} 2159 2160// ---------------------------------------------------------------------------- 2161// debugging 2162// ---------------------------------------------------------------------------- 2163 2164void Layer::dump(String8& result, Colorizer& colorizer) const 2165{ 2166 const Layer::State& s(getDrawingState()); 2167 2168 colorizer.colorize(result, Colorizer::GREEN); 2169 result.appendFormat( 2170 "+ %s %p (%s)\n", 2171 getTypeId(), this, getName().string()); 2172 colorizer.reset(result); 2173 2174 s.activeTransparentRegion.dump(result, "transparentRegion"); 2175 visibleRegion.dump(result, "visibleRegion"); 2176 surfaceDamageRegion.dump(result, "surfaceDamageRegion"); 2177 sp<Client> client(mClientRef.promote()); 2178 2179 result.appendFormat( " " 2180 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), " 2181 "crop=(%4d,%4d,%4d,%4d), finalCrop=(%4d,%4d,%4d,%4d), " 2182 "isOpaque=%1d, invalidate=%1d, " 2183#ifdef USE_HWC2 2184 "alpha=%.3f, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2185#else 2186 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2187#endif 2188 " client=%p\n", 2189 s.layerStack, s.z, s.active.transform.tx(), s.active.transform.ty(), s.active.w, s.active.h, 2190 s.crop.left, s.crop.top, 2191 s.crop.right, s.crop.bottom, 2192 s.finalCrop.left, s.finalCrop.top, 2193 s.finalCrop.right, s.finalCrop.bottom, 2194 isOpaque(s), contentDirty, 2195 s.alpha, s.flags, 2196 s.active.transform[0][0], s.active.transform[0][1], 2197 s.active.transform[1][0], s.active.transform[1][1], 2198 client.get()); 2199 2200 sp<const GraphicBuffer> buf0(mActiveBuffer); 2201 uint32_t w0=0, h0=0, s0=0, f0=0; 2202 if (buf0 != 0) { 2203 w0 = buf0->getWidth(); 2204 h0 = buf0->getHeight(); 2205 s0 = buf0->getStride(); 2206 f0 = buf0->format; 2207 } 2208 result.appendFormat( 2209 " " 2210 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 2211 " queued-frames=%d, mRefreshPending=%d\n", 2212 mFormat, w0, h0, s0,f0, 2213 mQueuedFrames, mRefreshPending); 2214 2215 if (mSurfaceFlingerConsumer != 0) { 2216 mSurfaceFlingerConsumer->dump(result, " "); 2217 } 2218} 2219 2220void Layer::dumpFrameStats(String8& result) const { 2221 mFrameTracker.dumpStats(result); 2222} 2223 2224void Layer::clearFrameStats() { 2225 mFrameTracker.clearStats(); 2226} 2227 2228void Layer::logFrameStats() { 2229 mFrameTracker.logAndResetStats(mName); 2230} 2231 2232void Layer::getFrameStats(FrameStats* outStats) const { 2233 mFrameTracker.getStats(outStats); 2234} 2235 2236void Layer::getFenceData(String8* outName, uint64_t* outFrameNumber, 2237 bool* outIsGlesComposition, nsecs_t* outPostedTime, 2238 sp<Fence>* outAcquireFence, sp<Fence>* outPrevReleaseFence) const { 2239 *outName = mName; 2240 *outFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2241 2242#ifdef USE_HWC2 2243 *outIsGlesComposition = mHwcLayers.count(HWC_DISPLAY_PRIMARY) ? 2244 mHwcLayers.at(HWC_DISPLAY_PRIMARY).compositionType == 2245 HWC2::Composition::Client : true; 2246#else 2247 *outIsGlesComposition = mIsGlesComposition; 2248#endif 2249 *outPostedTime = mSurfaceFlingerConsumer->getTimestamp(); 2250 *outAcquireFence = mSurfaceFlingerConsumer->getCurrentFence(); 2251 *outPrevReleaseFence = mSurfaceFlingerConsumer->getPrevReleaseFence(); 2252} 2253 2254std::vector<OccupancyTracker::Segment> Layer::getOccupancyHistory( 2255 bool forceFlush) { 2256 std::vector<OccupancyTracker::Segment> history; 2257 status_t result = mSurfaceFlingerConsumer->getOccupancyHistory(forceFlush, 2258 &history); 2259 if (result != NO_ERROR) { 2260 ALOGW("[%s] Failed to obtain occupancy history (%d)", mName.string(), 2261 result); 2262 return {}; 2263 } 2264 return history; 2265} 2266 2267bool Layer::getTransformToDisplayInverse() const { 2268 return mSurfaceFlingerConsumer->getTransformToDisplayInverse(); 2269} 2270 2271// --------------------------------------------------------------------------- 2272 2273}; // namespace android 2274 2275#if defined(__gl_h_) 2276#error "don't include gl/gl.h in this file" 2277#endif 2278 2279#if defined(__gl2_h_) 2280#error "don't include gl2/gl2.h in this file" 2281#endif 2282