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