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