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