Layer.cpp revision 0f67b3f01fc74bbd8cf4be24fce4a1e42f102282
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 // If the transform has been rotated the axis of flip has been swapped 452 // so we need to swap which flip operations we are performing 453 bool is_h_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; 454 bool is_v_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; 455 if (is_h_flipped != is_v_flipped) { 456 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 457 NATIVE_WINDOW_TRANSFORM_FLIP_H; 458 } 459 } 460 // and apply to the current transform 461 invTransform = (Transform(invTransform) * Transform(invTransformOrient)).getOrientation(); 462 } 463 464 int winWidth = s.active.w; 465 int winHeight = s.active.h; 466 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 467 // If the activeCrop has been rotate the ends are rotated but not 468 // the space itself so when transforming ends back we can't rely on 469 // a modification of the axes of rotation. To account for this we 470 // need to reorient the inverse rotation in terms of the current 471 // axes of rotation. 472 bool is_h_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; 473 bool is_v_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; 474 if (is_h_flipped == is_v_flipped) { 475 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 476 NATIVE_WINDOW_TRANSFORM_FLIP_H; 477 } 478 winWidth = s.active.h; 479 winHeight = s.active.w; 480 } 481 const Rect winCrop = activeCrop.transform( 482 invTransform, s.active.w, s.active.h); 483 484 // below, crop is intersected with winCrop expressed in crop's coordinate space 485 float xScale = crop.getWidth() / float(winWidth); 486 float yScale = crop.getHeight() / float(winHeight); 487 488 float insetL = winCrop.left * xScale; 489 float insetT = winCrop.top * yScale; 490 float insetR = (winWidth - winCrop.right ) * xScale; 491 float insetB = (winHeight - winCrop.bottom) * yScale; 492 493 crop.left += insetL; 494 crop.top += insetT; 495 crop.right -= insetR; 496 crop.bottom -= insetB; 497 498 return crop; 499} 500 501#ifdef USE_HWC2 502void Layer::setGeometry(const sp<const DisplayDevice>& displayDevice) 503#else 504void Layer::setGeometry( 505 const sp<const DisplayDevice>& hw, 506 HWComposer::HWCLayerInterface& layer) 507#endif 508{ 509#ifdef USE_HWC2 510 const auto hwcId = displayDevice->getHwcDisplayId(); 511 auto& hwcInfo = mHwcLayers[hwcId]; 512#else 513 layer.setDefaultState(); 514#endif 515 516 // enable this layer 517#ifdef USE_HWC2 518 hwcInfo.forceClientComposition = false; 519 520 if (isSecure() && !displayDevice->isSecure()) { 521 hwcInfo.forceClientComposition = true; 522 } 523 524 auto& hwcLayer = hwcInfo.layer; 525#else 526 layer.setSkip(false); 527 528 if (isSecure() && !hw->isSecure()) { 529 layer.setSkip(true); 530 } 531#endif 532 533 // this gives us only the "orientation" component of the transform 534 const State& s(getDrawingState()); 535#ifdef USE_HWC2 536 if (!isOpaque(s) || s.alpha != 1.0f) { 537 auto blendMode = mPremultipliedAlpha ? 538 HWC2::BlendMode::Premultiplied : HWC2::BlendMode::Coverage; 539 auto error = hwcLayer->setBlendMode(blendMode); 540 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set blend mode %s:" 541 " %s (%d)", mName.string(), to_string(blendMode).c_str(), 542 to_string(error).c_str(), static_cast<int32_t>(error)); 543 } 544#else 545 if (!isOpaque(s) || s.alpha != 0xFF) { 546 layer.setBlending(mPremultipliedAlpha ? 547 HWC_BLENDING_PREMULT : 548 HWC_BLENDING_COVERAGE); 549 } 550#endif 551 552 // apply the layer's transform, followed by the display's global transform 553 // here we're guaranteed that the layer's transform preserves rects 554 Region activeTransparentRegion(s.activeTransparentRegion); 555 if (!s.crop.isEmpty()) { 556 Rect activeCrop(s.crop); 557 activeCrop = s.active.transform.transform(activeCrop); 558#ifdef USE_HWC2 559 if(!activeCrop.intersect(displayDevice->getViewport(), &activeCrop)) { 560#else 561 if(!activeCrop.intersect(hw->getViewport(), &activeCrop)) { 562#endif 563 activeCrop.clear(); 564 } 565 activeCrop = s.active.transform.inverse().transform(activeCrop); 566 // This needs to be here as transform.transform(Rect) computes the 567 // transformed rect and then takes the bounding box of the result before 568 // returning. This means 569 // transform.inverse().transform(transform.transform(Rect)) != Rect 570 // in which case we need to make sure the final rect is clipped to the 571 // display bounds. 572 if(!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) { 573 activeCrop.clear(); 574 } 575 // mark regions outside the crop as transparent 576 activeTransparentRegion.orSelf(Rect(0, 0, s.active.w, activeCrop.top)); 577 activeTransparentRegion.orSelf(Rect(0, activeCrop.bottom, 578 s.active.w, s.active.h)); 579 activeTransparentRegion.orSelf(Rect(0, activeCrop.top, 580 activeCrop.left, activeCrop.bottom)); 581 activeTransparentRegion.orSelf(Rect(activeCrop.right, activeCrop.top, 582 s.active.w, activeCrop.bottom)); 583 } 584 Rect frame(s.active.transform.transform(computeBounds(activeTransparentRegion))); 585 if (!s.finalCrop.isEmpty()) { 586 if(!frame.intersect(s.finalCrop, &frame)) { 587 frame.clear(); 588 } 589 } 590#ifdef USE_HWC2 591 if (!frame.intersect(displayDevice->getViewport(), &frame)) { 592 frame.clear(); 593 } 594 const Transform& tr(displayDevice->getTransform()); 595 Rect transformedFrame = tr.transform(frame); 596 auto error = hwcLayer->setDisplayFrame(transformedFrame); 597 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set display frame " 598 "[%d, %d, %d, %d]: %s (%d)", mName.string(), transformedFrame.left, 599 transformedFrame.top, transformedFrame.right, 600 transformedFrame.bottom, to_string(error).c_str(), 601 static_cast<int32_t>(error)); 602 603 FloatRect sourceCrop = computeCrop(displayDevice); 604 error = hwcLayer->setSourceCrop(sourceCrop); 605 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set source crop " 606 "[%.3f, %.3f, %.3f, %.3f]: %s (%d)", mName.string(), 607 sourceCrop.left, sourceCrop.top, sourceCrop.right, 608 sourceCrop.bottom, to_string(error).c_str(), 609 static_cast<int32_t>(error)); 610 611 error = hwcLayer->setPlaneAlpha(s.alpha); 612 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set plane alpha %.3f: " 613 "%s (%d)", mName.string(), s.alpha, to_string(error).c_str(), 614 static_cast<int32_t>(error)); 615 616 error = hwcLayer->setZOrder(s.z); 617 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set Z %u: %s (%d)", 618 mName.string(), s.z, to_string(error).c_str(), 619 static_cast<int32_t>(error)); 620#else 621 if (!frame.intersect(hw->getViewport(), &frame)) { 622 frame.clear(); 623 } 624 const Transform& tr(hw->getTransform()); 625 layer.setFrame(tr.transform(frame)); 626 layer.setCrop(computeCrop(hw)); 627 layer.setPlaneAlpha(s.alpha); 628#endif 629 630 /* 631 * Transformations are applied in this order: 632 * 1) buffer orientation/flip/mirror 633 * 2) state transformation (window manager) 634 * 3) layer orientation (screen orientation) 635 * (NOTE: the matrices are multiplied in reverse order) 636 */ 637 638 const Transform bufferOrientation(mCurrentTransform); 639 Transform transform(tr * s.active.transform * bufferOrientation); 640 641 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { 642 /* 643 * the code below applies the primary display's inverse transform to the 644 * buffer 645 */ 646 uint32_t invTransform = 647 DisplayDevice::getPrimaryDisplayOrientationTransform(); 648 649 uint32_t t_orientation = transform.getOrientation(); 650 // calculate the inverse transform 651 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 652 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 653 NATIVE_WINDOW_TRANSFORM_FLIP_H; 654 // If the transform has been rotated the axis of flip has been swapped 655 // so we need to swap which flip operations we are performing 656 bool is_h_flipped = (t_orientation & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; 657 bool is_v_flipped = (t_orientation & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; 658 if (is_h_flipped != is_v_flipped) { 659 t_orientation ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 660 NATIVE_WINDOW_TRANSFORM_FLIP_H; 661 } 662 } 663 // and apply to the current transform 664 transform = Transform(t_orientation) * Transform(invTransform); 665 } 666 667 // this gives us only the "orientation" component of the transform 668 const uint32_t orientation = transform.getOrientation(); 669#ifdef USE_HWC2 670 if (orientation & Transform::ROT_INVALID) { 671 // we can only handle simple transformation 672 hwcInfo.forceClientComposition = true; 673 } else { 674 auto transform = static_cast<HWC2::Transform>(orientation); 675 auto error = hwcLayer->setTransform(transform); 676 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set transform %s: " 677 "%s (%d)", mName.string(), to_string(transform).c_str(), 678 to_string(error).c_str(), static_cast<int32_t>(error)); 679 } 680#else 681 if (orientation & Transform::ROT_INVALID) { 682 // we can only handle simple transformation 683 layer.setSkip(true); 684 } else { 685 layer.setTransform(orientation); 686 } 687#endif 688} 689 690#ifdef USE_HWC2 691void Layer::forceClientComposition(int32_t hwcId) { 692 if (mHwcLayers.count(hwcId) == 0) { 693 ALOGE("forceClientComposition: no HWC layer found (%d)", hwcId); 694 return; 695 } 696 697 mHwcLayers[hwcId].forceClientComposition = true; 698} 699#endif 700 701#ifdef USE_HWC2 702void Layer::setPerFrameData(const sp<const DisplayDevice>& displayDevice) { 703 // Apply this display's projection's viewport to the visible region 704 // before giving it to the HWC HAL. 705 const Transform& tr = displayDevice->getTransform(); 706 const auto& viewport = displayDevice->getViewport(); 707 Region visible = tr.transform(visibleRegion.intersect(viewport)); 708 auto hwcId = displayDevice->getHwcDisplayId(); 709 auto& hwcLayer = mHwcLayers[hwcId].layer; 710 auto error = hwcLayer->setVisibleRegion(visible); 711 if (error != HWC2::Error::None) { 712 ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(), 713 to_string(error).c_str(), static_cast<int32_t>(error)); 714 visible.dump(LOG_TAG); 715 } 716 717 error = hwcLayer->setSurfaceDamage(surfaceDamageRegion); 718 if (error != HWC2::Error::None) { 719 ALOGE("[%s] Failed to set surface damage: %s (%d)", mName.string(), 720 to_string(error).c_str(), static_cast<int32_t>(error)); 721 surfaceDamageRegion.dump(LOG_TAG); 722 } 723 724 // Sideband layers 725 if (mSidebandStream.get()) { 726 setCompositionType(hwcId, HWC2::Composition::Sideband); 727 ALOGV("[%s] Requesting Sideband composition", mName.string()); 728 error = hwcLayer->setSidebandStream(mSidebandStream->handle()); 729 if (error != HWC2::Error::None) { 730 ALOGE("[%s] Failed to set sideband stream %p: %s (%d)", 731 mName.string(), mSidebandStream->handle(), 732 to_string(error).c_str(), static_cast<int32_t>(error)); 733 } 734 return; 735 } 736 737 // Client or SolidColor layers 738 if (mActiveBuffer == nullptr || mActiveBuffer->handle == nullptr || 739 mHwcLayers[hwcId].forceClientComposition) { 740 // TODO: This also includes solid color layers, but no API exists to 741 // setup a solid color layer yet 742 ALOGV("[%s] Requesting Client composition", mName.string()); 743 setCompositionType(hwcId, HWC2::Composition::Client); 744 error = hwcLayer->setBuffer(nullptr, Fence::NO_FENCE); 745 if (error != HWC2::Error::None) { 746 ALOGE("[%s] Failed to set null buffer: %s (%d)", mName.string(), 747 to_string(error).c_str(), static_cast<int32_t>(error)); 748 } 749 return; 750 } 751 752 // Device or Cursor layers 753 if (mPotentialCursor) { 754 ALOGV("[%s] Requesting Cursor composition", mName.string()); 755 setCompositionType(hwcId, HWC2::Composition::Cursor); 756 } else { 757 ALOGV("[%s] Requesting Device composition", mName.string()); 758 setCompositionType(hwcId, HWC2::Composition::Device); 759 } 760 761 auto acquireFence = mSurfaceFlingerConsumer->getCurrentFence(); 762 error = hwcLayer->setBuffer(mActiveBuffer->handle, acquireFence); 763 if (error != HWC2::Error::None) { 764 ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(), 765 mActiveBuffer->handle, to_string(error).c_str(), 766 static_cast<int32_t>(error)); 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 // If the layer is hidden, signal and clear out all local sync points so 1482 // that transactions for layers depending on this layer's frames becoming 1483 // visible are not blocked 1484 if (c.flags & layer_state_t::eLayerHidden) { 1485 Mutex::Autolock lock(mLocalSyncPointMutex); 1486 for (auto& point : mLocalSyncPoints) { 1487 point->setFrameAvailable(); 1488 } 1489 mLocalSyncPoints.clear(); 1490 } 1491 1492 // Commit the transaction 1493 commitTransaction(c); 1494 return flags; 1495} 1496 1497void Layer::commitTransaction(const State& stateToCommit) { 1498 mDrawingState = stateToCommit; 1499} 1500 1501uint32_t Layer::getTransactionFlags(uint32_t flags) { 1502 return android_atomic_and(~flags, &mTransactionFlags) & flags; 1503} 1504 1505uint32_t Layer::setTransactionFlags(uint32_t flags) { 1506 return android_atomic_or(flags, &mTransactionFlags); 1507} 1508 1509bool Layer::setPosition(float x, float y) { 1510 if (mCurrentState.requested.transform.tx() == x && mCurrentState.requested.transform.ty() == y) 1511 return false; 1512 mCurrentState.sequence++; 1513 1514 // We update the requested and active position simultaneously because 1515 // we want to apply the position portion of the transform matrix immediately, 1516 // but still delay scaling when resizing a SCALING_MODE_FREEZE layer. 1517 mCurrentState.requested.transform.set(x, y); 1518 mCurrentState.active.transform.set(x, y); 1519 1520 mCurrentState.modified = true; 1521 setTransactionFlags(eTransactionNeeded); 1522 return true; 1523} 1524bool Layer::setLayer(uint32_t z) { 1525 if (mCurrentState.z == z) 1526 return false; 1527 mCurrentState.sequence++; 1528 mCurrentState.z = z; 1529 mCurrentState.modified = true; 1530 setTransactionFlags(eTransactionNeeded); 1531 return true; 1532} 1533bool Layer::setSize(uint32_t w, uint32_t h) { 1534 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 1535 return false; 1536 mCurrentState.requested.w = w; 1537 mCurrentState.requested.h = h; 1538 mCurrentState.modified = true; 1539 setTransactionFlags(eTransactionNeeded); 1540 return true; 1541} 1542#ifdef USE_HWC2 1543bool Layer::setAlpha(float alpha) { 1544#else 1545bool Layer::setAlpha(uint8_t alpha) { 1546#endif 1547 if (mCurrentState.alpha == alpha) 1548 return false; 1549 mCurrentState.sequence++; 1550 mCurrentState.alpha = alpha; 1551 mCurrentState.modified = true; 1552 setTransactionFlags(eTransactionNeeded); 1553 return true; 1554} 1555bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 1556 mCurrentState.sequence++; 1557 mCurrentState.requested.transform.set( 1558 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); 1559 mCurrentState.modified = true; 1560 setTransactionFlags(eTransactionNeeded); 1561 return true; 1562} 1563bool Layer::setTransparentRegionHint(const Region& transparent) { 1564 mCurrentState.requestedTransparentRegion = transparent; 1565 mCurrentState.modified = true; 1566 setTransactionFlags(eTransactionNeeded); 1567 return true; 1568} 1569bool Layer::setFlags(uint8_t flags, uint8_t mask) { 1570 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 1571 if (mCurrentState.flags == newFlags) 1572 return false; 1573 mCurrentState.sequence++; 1574 mCurrentState.flags = newFlags; 1575 mCurrentState.mask = mask; 1576 mCurrentState.modified = true; 1577 setTransactionFlags(eTransactionNeeded); 1578 return true; 1579} 1580bool Layer::setCrop(const Rect& crop) { 1581 if (mCurrentState.crop == crop) 1582 return false; 1583 mCurrentState.sequence++; 1584 mCurrentState.crop = crop; 1585 mCurrentState.modified = true; 1586 setTransactionFlags(eTransactionNeeded); 1587 return true; 1588} 1589bool Layer::setFinalCrop(const Rect& crop) { 1590 if (mCurrentState.finalCrop == crop) 1591 return false; 1592 mCurrentState.sequence++; 1593 mCurrentState.finalCrop = crop; 1594 mCurrentState.modified = true; 1595 setTransactionFlags(eTransactionNeeded); 1596 return true; 1597} 1598 1599bool Layer::setOverrideScalingMode(int32_t scalingMode) { 1600 if (scalingMode == mOverrideScalingMode) 1601 return false; 1602 mOverrideScalingMode = scalingMode; 1603 return true; 1604} 1605 1606uint32_t Layer::getEffectiveScalingMode() const { 1607 if (mOverrideScalingMode >= 0) { 1608 return mOverrideScalingMode; 1609 } 1610 return mCurrentScalingMode; 1611} 1612 1613bool Layer::setLayerStack(uint32_t layerStack) { 1614 if (mCurrentState.layerStack == layerStack) 1615 return false; 1616 mCurrentState.sequence++; 1617 mCurrentState.layerStack = layerStack; 1618 mCurrentState.modified = true; 1619 setTransactionFlags(eTransactionNeeded); 1620 return true; 1621} 1622 1623void Layer::deferTransactionUntil(const sp<IBinder>& handle, 1624 uint64_t frameNumber) { 1625 mCurrentState.handle = handle; 1626 mCurrentState.frameNumber = frameNumber; 1627 // We don't set eTransactionNeeded, because just receiving a deferral 1628 // request without any other state updates shouldn't actually induce a delay 1629 mCurrentState.modified = true; 1630 pushPendingState(); 1631 mCurrentState.handle = nullptr; 1632 mCurrentState.frameNumber = 0; 1633 mCurrentState.modified = false; 1634} 1635 1636void Layer::useSurfaceDamage() { 1637 if (mFlinger->mForceFullDamage) { 1638 surfaceDamageRegion = Region::INVALID_REGION; 1639 } else { 1640 surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage(); 1641 } 1642} 1643 1644void Layer::useEmptyDamage() { 1645 surfaceDamageRegion.clear(); 1646} 1647 1648// ---------------------------------------------------------------------------- 1649// pageflip handling... 1650// ---------------------------------------------------------------------------- 1651 1652bool Layer::shouldPresentNow(const DispSync& dispSync) const { 1653 if (mSidebandStreamChanged || mAutoRefresh) { 1654 return true; 1655 } 1656 1657 Mutex::Autolock lock(mQueueItemLock); 1658 if (mQueueItems.empty()) { 1659 return false; 1660 } 1661 auto timestamp = mQueueItems[0].mTimestamp; 1662 nsecs_t expectedPresent = 1663 mSurfaceFlingerConsumer->computeExpectedPresent(dispSync); 1664 1665 // Ignore timestamps more than a second in the future 1666 bool isPlausible = timestamp < (expectedPresent + s2ns(1)); 1667 ALOGW_IF(!isPlausible, "[%s] Timestamp %" PRId64 " seems implausible " 1668 "relative to expectedPresent %" PRId64, mName.string(), timestamp, 1669 expectedPresent); 1670 1671 bool isDue = timestamp < expectedPresent; 1672 return isDue || !isPlausible; 1673} 1674 1675bool Layer::onPreComposition() { 1676 mRefreshPending = false; 1677 return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh; 1678} 1679 1680void Layer::onPostComposition() { 1681 if (mFrameLatencyNeeded) { 1682 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 1683 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 1684 1685 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 1686 if (frameReadyFence->isValid()) { 1687 mFrameTracker.setFrameReadyFence(frameReadyFence); 1688 } else { 1689 // There was no fence for this frame, so assume that it was ready 1690 // to be presented at the desired present time. 1691 mFrameTracker.setFrameReadyTime(desiredPresentTime); 1692 } 1693 1694 const HWComposer& hwc = mFlinger->getHwComposer(); 1695#ifdef USE_HWC2 1696 sp<Fence> presentFence = hwc.getRetireFence(HWC_DISPLAY_PRIMARY); 1697#else 1698 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 1699#endif 1700 if (presentFence->isValid()) { 1701 mFrameTracker.setActualPresentFence(presentFence); 1702 } else { 1703 // The HWC doesn't support present fences, so use the refresh 1704 // timestamp instead. 1705 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 1706 mFrameTracker.setActualPresentTime(presentTime); 1707 } 1708 1709 mFrameTracker.advanceFrame(); 1710 mFrameLatencyNeeded = false; 1711 } 1712} 1713 1714#ifdef USE_HWC2 1715void Layer::releasePendingBuffer() { 1716 mSurfaceFlingerConsumer->releasePendingBuffer(); 1717} 1718#endif 1719 1720bool Layer::isVisible() const { 1721 const Layer::State& s(mDrawingState); 1722#ifdef USE_HWC2 1723 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha > 0.0f 1724 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1725#else 1726 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha 1727 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1728#endif 1729} 1730 1731Region Layer::latchBuffer(bool& recomputeVisibleRegions) 1732{ 1733 ATRACE_CALL(); 1734 1735 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { 1736 // mSidebandStreamChanged was true 1737 mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream(); 1738 if (mSidebandStream != NULL) { 1739 setTransactionFlags(eTransactionNeeded); 1740 mFlinger->setTransactionFlags(eTraversalNeeded); 1741 } 1742 recomputeVisibleRegions = true; 1743 1744 const State& s(getDrawingState()); 1745 return s.active.transform.transform(Region(Rect(s.active.w, s.active.h))); 1746 } 1747 1748 Region outDirtyRegion; 1749 if (mQueuedFrames > 0 || mAutoRefresh) { 1750 1751 // if we've already called updateTexImage() without going through 1752 // a composition step, we have to skip this layer at this point 1753 // because we cannot call updateTeximage() without a corresponding 1754 // compositionComplete() call. 1755 // we'll trigger an update in onPreComposition(). 1756 if (mRefreshPending) { 1757 return outDirtyRegion; 1758 } 1759 1760 // Capture the old state of the layer for comparisons later 1761 const State& s(getDrawingState()); 1762 const bool oldOpacity = isOpaque(s); 1763 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 1764 1765 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 1766 Layer::State& front; 1767 Layer::State& current; 1768 bool& recomputeVisibleRegions; 1769 bool stickyTransformSet; 1770 const char* name; 1771 int32_t overrideScalingMode; 1772 1773 Reject(Layer::State& front, Layer::State& current, 1774 bool& recomputeVisibleRegions, bool stickySet, 1775 const char* name, 1776 int32_t overrideScalingMode) 1777 : front(front), current(current), 1778 recomputeVisibleRegions(recomputeVisibleRegions), 1779 stickyTransformSet(stickySet), 1780 name(name), 1781 overrideScalingMode(overrideScalingMode) { 1782 } 1783 1784 virtual bool reject(const sp<GraphicBuffer>& buf, 1785 const BufferItem& item) { 1786 if (buf == NULL) { 1787 return false; 1788 } 1789 1790 uint32_t bufWidth = buf->getWidth(); 1791 uint32_t bufHeight = buf->getHeight(); 1792 1793 // check that we received a buffer of the right size 1794 // (Take the buffer's orientation into account) 1795 if (item.mTransform & Transform::ROT_90) { 1796 swap(bufWidth, bufHeight); 1797 } 1798 1799 int actualScalingMode = overrideScalingMode >= 0 ? 1800 overrideScalingMode : item.mScalingMode; 1801 bool isFixedSize = actualScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1802 if (front.active != front.requested) { 1803 1804 if (isFixedSize || 1805 (bufWidth == front.requested.w && 1806 bufHeight == front.requested.h)) 1807 { 1808 // Here we pretend the transaction happened by updating the 1809 // current and drawing states. Drawing state is only accessed 1810 // in this thread, no need to have it locked 1811 front.active = front.requested; 1812 1813 // We also need to update the current state so that 1814 // we don't end-up overwriting the drawing state with 1815 // this stale current state during the next transaction 1816 // 1817 // NOTE: We don't need to hold the transaction lock here 1818 // because State::active is only accessed from this thread. 1819 current.active = front.active; 1820 current.modified = true; 1821 1822 // recompute visible region 1823 recomputeVisibleRegions = true; 1824 } 1825 1826 ALOGD_IF(DEBUG_RESIZE, 1827 "[%s] latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 1828 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1829 " requested={ wh={%4u,%4u} }}\n", 1830 name, 1831 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 1832 front.active.w, front.active.h, 1833 front.crop.left, 1834 front.crop.top, 1835 front.crop.right, 1836 front.crop.bottom, 1837 front.crop.getWidth(), 1838 front.crop.getHeight(), 1839 front.requested.w, front.requested.h); 1840 } 1841 1842 if (!isFixedSize && !stickyTransformSet) { 1843 if (front.active.w != bufWidth || 1844 front.active.h != bufHeight) { 1845 // reject this buffer 1846 ALOGE("[%s] rejecting buffer: " 1847 "bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}", 1848 name, bufWidth, bufHeight, front.active.w, front.active.h); 1849 return true; 1850 } 1851 } 1852 1853 // if the transparent region has changed (this test is 1854 // conservative, but that's fine, worst case we're doing 1855 // a bit of extra work), we latch the new one and we 1856 // trigger a visible-region recompute. 1857 if (!front.activeTransparentRegion.isTriviallyEqual( 1858 front.requestedTransparentRegion)) { 1859 front.activeTransparentRegion = front.requestedTransparentRegion; 1860 1861 // We also need to update the current state so that 1862 // we don't end-up overwriting the drawing state with 1863 // this stale current state during the next transaction 1864 // 1865 // NOTE: We don't need to hold the transaction lock here 1866 // because State::active is only accessed from this thread. 1867 current.activeTransparentRegion = front.activeTransparentRegion; 1868 1869 // recompute visible region 1870 recomputeVisibleRegions = true; 1871 } 1872 1873 return false; 1874 } 1875 }; 1876 1877 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 1878 getProducerStickyTransform() != 0, mName.string(), 1879 mOverrideScalingMode); 1880 1881 1882 // Check all of our local sync points to ensure that all transactions 1883 // which need to have been applied prior to the frame which is about to 1884 // be latched have signaled 1885 1886 auto headFrameNumber = getHeadFrameNumber(); 1887 bool matchingFramesFound = false; 1888 bool allTransactionsApplied = true; 1889 { 1890 Mutex::Autolock lock(mLocalSyncPointMutex); 1891 for (auto& point : mLocalSyncPoints) { 1892 if (point->getFrameNumber() > headFrameNumber) { 1893 break; 1894 } 1895 1896 matchingFramesFound = true; 1897 1898 if (!point->frameIsAvailable()) { 1899 // We haven't notified the remote layer that the frame for 1900 // this point is available yet. Notify it now, and then 1901 // abort this attempt to latch. 1902 point->setFrameAvailable(); 1903 allTransactionsApplied = false; 1904 break; 1905 } 1906 1907 allTransactionsApplied &= point->transactionIsApplied(); 1908 } 1909 } 1910 1911 if (matchingFramesFound && !allTransactionsApplied) { 1912 mFlinger->signalLayerUpdate(); 1913 return outDirtyRegion; 1914 } 1915 1916 // This boolean is used to make sure that SurfaceFlinger's shadow copy 1917 // of the buffer queue isn't modified when the buffer queue is returning 1918 // BufferItem's that weren't actually queued. This can happen in shared 1919 // buffer mode. 1920 bool queuedBuffer = false; 1921 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, 1922 mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer, 1923 mLastFrameNumberReceived); 1924 if (updateResult == BufferQueue::PRESENT_LATER) { 1925 // Producer doesn't want buffer to be displayed yet. Signal a 1926 // layer update so we check again at the next opportunity. 1927 mFlinger->signalLayerUpdate(); 1928 return outDirtyRegion; 1929 } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) { 1930 // If the buffer has been rejected, remove it from the shadow queue 1931 // and return early 1932 if (queuedBuffer) { 1933 Mutex::Autolock lock(mQueueItemLock); 1934 mQueueItems.removeAt(0); 1935 android_atomic_dec(&mQueuedFrames); 1936 } 1937 return outDirtyRegion; 1938 } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { 1939 // This can occur if something goes wrong when trying to create the 1940 // EGLImage for this buffer. If this happens, the buffer has already 1941 // been released, so we need to clean up the queue and bug out 1942 // early. 1943 if (queuedBuffer) { 1944 Mutex::Autolock lock(mQueueItemLock); 1945 mQueueItems.clear(); 1946 android_atomic_and(0, &mQueuedFrames); 1947 } 1948 1949 // Once we have hit this state, the shadow queue may no longer 1950 // correctly reflect the incoming BufferQueue's contents, so even if 1951 // updateTexImage starts working, the only safe course of action is 1952 // to continue to ignore updates. 1953 mUpdateTexImageFailed = true; 1954 1955 return outDirtyRegion; 1956 } 1957 1958 if (queuedBuffer) { 1959 // Autolock scope 1960 auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 1961 1962 Mutex::Autolock lock(mQueueItemLock); 1963 1964 // Remove any stale buffers that have been dropped during 1965 // updateTexImage 1966 while (mQueueItems[0].mFrameNumber != currentFrameNumber) { 1967 mQueueItems.removeAt(0); 1968 android_atomic_dec(&mQueuedFrames); 1969 } 1970 1971 mQueueItems.removeAt(0); 1972 } 1973 1974 1975 // Decrement the queued-frames count. Signal another event if we 1976 // have more frames pending. 1977 if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) 1978 || mAutoRefresh) { 1979 mFlinger->signalLayerUpdate(); 1980 } 1981 1982 if (updateResult != NO_ERROR) { 1983 // something happened! 1984 recomputeVisibleRegions = true; 1985 return outDirtyRegion; 1986 } 1987 1988 // update the active buffer 1989 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 1990 if (mActiveBuffer == NULL) { 1991 // this can only happen if the very first buffer was rejected. 1992 return outDirtyRegion; 1993 } 1994 1995 mRefreshPending = true; 1996 mFrameLatencyNeeded = true; 1997 if (oldActiveBuffer == NULL) { 1998 // the first time we receive a buffer, we need to trigger a 1999 // geometry invalidation. 2000 recomputeVisibleRegions = true; 2001 } 2002 2003 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 2004 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 2005 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 2006 if ((crop != mCurrentCrop) || 2007 (transform != mCurrentTransform) || 2008 (scalingMode != mCurrentScalingMode)) 2009 { 2010 mCurrentCrop = crop; 2011 mCurrentTransform = transform; 2012 mCurrentScalingMode = scalingMode; 2013 recomputeVisibleRegions = true; 2014 } 2015 2016 if (oldActiveBuffer != NULL) { 2017 uint32_t bufWidth = mActiveBuffer->getWidth(); 2018 uint32_t bufHeight = mActiveBuffer->getHeight(); 2019 if (bufWidth != uint32_t(oldActiveBuffer->width) || 2020 bufHeight != uint32_t(oldActiveBuffer->height)) { 2021 recomputeVisibleRegions = true; 2022 } 2023 } 2024 2025 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 2026 if (oldOpacity != isOpaque(s)) { 2027 recomputeVisibleRegions = true; 2028 } 2029 2030 mCurrentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2031 2032 // Remove any sync points corresponding to the buffer which was just 2033 // latched 2034 { 2035 Mutex::Autolock lock(mLocalSyncPointMutex); 2036 auto point = mLocalSyncPoints.begin(); 2037 while (point != mLocalSyncPoints.end()) { 2038 if (!(*point)->frameIsAvailable() || 2039 !(*point)->transactionIsApplied()) { 2040 // This sync point must have been added since we started 2041 // latching. Don't drop it yet. 2042 ++point; 2043 continue; 2044 } 2045 2046 if ((*point)->getFrameNumber() <= mCurrentFrameNumber) { 2047 point = mLocalSyncPoints.erase(point); 2048 } else { 2049 ++point; 2050 } 2051 } 2052 } 2053 2054 // FIXME: postedRegion should be dirty & bounds 2055 Region dirtyRegion(Rect(s.active.w, s.active.h)); 2056 2057 // transform the dirty region to window-manager space 2058 outDirtyRegion = (s.active.transform.transform(dirtyRegion)); 2059 } 2060 return outDirtyRegion; 2061} 2062 2063uint32_t Layer::getEffectiveUsage(uint32_t usage) const 2064{ 2065 // TODO: should we do something special if mSecure is set? 2066 if (mProtectedByApp) { 2067 // need a hardware-protected path to external video sink 2068 usage |= GraphicBuffer::USAGE_PROTECTED; 2069 } 2070 if (mPotentialCursor) { 2071 usage |= GraphicBuffer::USAGE_CURSOR; 2072 } 2073 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 2074 return usage; 2075} 2076 2077void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 2078 uint32_t orientation = 0; 2079 if (!mFlinger->mDebugDisableTransformHint) { 2080 // The transform hint is used to improve performance, but we can 2081 // only have a single transform hint, it cannot 2082 // apply to all displays. 2083 const Transform& planeTransform(hw->getTransform()); 2084 orientation = planeTransform.getOrientation(); 2085 if (orientation & Transform::ROT_INVALID) { 2086 orientation = 0; 2087 } 2088 } 2089 mSurfaceFlingerConsumer->setTransformHint(orientation); 2090} 2091 2092// ---------------------------------------------------------------------------- 2093// debugging 2094// ---------------------------------------------------------------------------- 2095 2096void Layer::dump(String8& result, Colorizer& colorizer) const 2097{ 2098 const Layer::State& s(getDrawingState()); 2099 2100 colorizer.colorize(result, Colorizer::GREEN); 2101 result.appendFormat( 2102 "+ %s %p (%s)\n", 2103 getTypeId(), this, getName().string()); 2104 colorizer.reset(result); 2105 2106 s.activeTransparentRegion.dump(result, "transparentRegion"); 2107 visibleRegion.dump(result, "visibleRegion"); 2108 surfaceDamageRegion.dump(result, "surfaceDamageRegion"); 2109 sp<Client> client(mClientRef.promote()); 2110 2111 result.appendFormat( " " 2112 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), " 2113 "crop=(%4d,%4d,%4d,%4d), finalCrop=(%4d,%4d,%4d,%4d), " 2114 "isOpaque=%1d, invalidate=%1d, " 2115#ifdef USE_HWC2 2116 "alpha=%.3f, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2117#else 2118 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2119#endif 2120 " client=%p\n", 2121 s.layerStack, s.z, s.active.transform.tx(), s.active.transform.ty(), s.active.w, s.active.h, 2122 s.crop.left, s.crop.top, 2123 s.crop.right, s.crop.bottom, 2124 s.finalCrop.left, s.finalCrop.top, 2125 s.finalCrop.right, s.finalCrop.bottom, 2126 isOpaque(s), contentDirty, 2127 s.alpha, s.flags, 2128 s.active.transform[0][0], s.active.transform[0][1], 2129 s.active.transform[1][0], s.active.transform[1][1], 2130 client.get()); 2131 2132 sp<const GraphicBuffer> buf0(mActiveBuffer); 2133 uint32_t w0=0, h0=0, s0=0, f0=0; 2134 if (buf0 != 0) { 2135 w0 = buf0->getWidth(); 2136 h0 = buf0->getHeight(); 2137 s0 = buf0->getStride(); 2138 f0 = buf0->format; 2139 } 2140 result.appendFormat( 2141 " " 2142 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 2143 " queued-frames=%d, mRefreshPending=%d\n", 2144 mFormat, w0, h0, s0,f0, 2145 mQueuedFrames, mRefreshPending); 2146 2147 if (mSurfaceFlingerConsumer != 0) { 2148 mSurfaceFlingerConsumer->dump(result, " "); 2149 } 2150} 2151 2152void Layer::dumpFrameStats(String8& result) const { 2153 mFrameTracker.dumpStats(result); 2154} 2155 2156void Layer::clearFrameStats() { 2157 mFrameTracker.clearStats(); 2158} 2159 2160void Layer::logFrameStats() { 2161 mFrameTracker.logAndResetStats(mName); 2162} 2163 2164void Layer::getFrameStats(FrameStats* outStats) const { 2165 mFrameTracker.getStats(outStats); 2166} 2167 2168void Layer::getFenceData(String8* outName, uint64_t* outFrameNumber, 2169 bool* outIsGlesComposition, nsecs_t* outPostedTime, 2170 sp<Fence>* outAcquireFence, sp<Fence>* outPrevReleaseFence) const { 2171 *outName = mName; 2172 *outFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2173 2174#ifdef USE_HWC2 2175 *outIsGlesComposition = mHwcLayers.count(HWC_DISPLAY_PRIMARY) ? 2176 mHwcLayers.at(HWC_DISPLAY_PRIMARY).compositionType == 2177 HWC2::Composition::Client : true; 2178#else 2179 *outIsGlesComposition = mIsGlesComposition; 2180#endif 2181 *outPostedTime = mSurfaceFlingerConsumer->getTimestamp(); 2182 *outAcquireFence = mSurfaceFlingerConsumer->getCurrentFence(); 2183 *outPrevReleaseFence = mSurfaceFlingerConsumer->getPrevReleaseFence(); 2184} 2185// --------------------------------------------------------------------------- 2186 2187Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 2188 const sp<Layer>& layer) 2189 : mFlinger(flinger), mLayer(layer) { 2190} 2191 2192Layer::LayerCleaner::~LayerCleaner() { 2193 // destroy client resources 2194 mFlinger->onLayerDestroyed(mLayer); 2195} 2196 2197// --------------------------------------------------------------------------- 2198}; // namespace android 2199 2200#if defined(__gl_h_) 2201#error "don't include gl/gl.h in this file" 2202#endif 2203 2204#if defined(__gl2_h_) 2205#error "don't include gl2/gl2.h in this file" 2206#endif 2207