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