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