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