Layer.cpp revision 792e529dee5b6cf839b982b4b06a37fbf1d3e28a
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 mSingleBufferMode(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 } else { 1004 break; 1005 } 1006 } else { 1007 popPendingState(); 1008 stateUpdateAvailable = true; 1009 } 1010 } 1011 1012 // If we still have pending updates, wake SurfaceFlinger back up and point 1013 // it at this layer so we can process them 1014 if (!mPendingStates.empty()) { 1015 setTransactionFlags(eTransactionNeeded); 1016 mFlinger->setTransactionFlags(eTraversalNeeded); 1017 } 1018 1019 mCurrentState.modified = false; 1020 return stateUpdateAvailable; 1021} 1022 1023void Layer::notifyAvailableFrames() { 1024 auto headFrameNumber = getHeadFrameNumber(); 1025 Mutex::Autolock lock(mLocalSyncPointMutex); 1026 for (auto& point : mLocalSyncPoints) { 1027 if (headFrameNumber >= point->getFrameNumber()) { 1028 point->setFrameAvailable(); 1029 } 1030 } 1031} 1032 1033uint32_t Layer::doTransaction(uint32_t flags) { 1034 ATRACE_CALL(); 1035 1036 pushPendingState(); 1037 if (!applyPendingStates()) { 1038 return 0; 1039 } 1040 1041 const Layer::State& s(getDrawingState()); 1042 const Layer::State& c(getCurrentState()); 1043 1044 const bool sizeChanged = (c.requested.w != s.requested.w) || 1045 (c.requested.h != s.requested.h); 1046 1047 if (sizeChanged) { 1048 // the size changed, we need to ask our client to request a new buffer 1049 ALOGD_IF(DEBUG_RESIZE, 1050 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 1051 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1052 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n" 1053 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1054 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 1055 this, getName().string(), mCurrentTransform, mCurrentScalingMode, 1056 c.active.w, c.active.h, 1057 c.active.crop.left, 1058 c.active.crop.top, 1059 c.active.crop.right, 1060 c.active.crop.bottom, 1061 c.active.crop.getWidth(), 1062 c.active.crop.getHeight(), 1063 c.requested.w, c.requested.h, 1064 c.requested.crop.left, 1065 c.requested.crop.top, 1066 c.requested.crop.right, 1067 c.requested.crop.bottom, 1068 c.requested.crop.getWidth(), 1069 c.requested.crop.getHeight(), 1070 s.active.w, s.active.h, 1071 s.active.crop.left, 1072 s.active.crop.top, 1073 s.active.crop.right, 1074 s.active.crop.bottom, 1075 s.active.crop.getWidth(), 1076 s.active.crop.getHeight(), 1077 s.requested.w, s.requested.h, 1078 s.requested.crop.left, 1079 s.requested.crop.top, 1080 s.requested.crop.right, 1081 s.requested.crop.bottom, 1082 s.requested.crop.getWidth(), 1083 s.requested.crop.getHeight()); 1084 1085 // record the new size, form this point on, when the client request 1086 // a buffer, it'll get the new size. 1087 mSurfaceFlingerConsumer->setDefaultBufferSize( 1088 c.requested.w, c.requested.h); 1089 } 1090 1091 if (!isFixedSize()) { 1092 1093 const bool resizePending = (c.requested.w != c.active.w) || 1094 (c.requested.h != c.active.h); 1095 1096 if (resizePending && mSidebandStream == NULL) { 1097 // don't let Layer::doTransaction update the drawing state 1098 // if we have a pending resize, unless we are in fixed-size mode. 1099 // the drawing state will be updated only once we receive a buffer 1100 // with the correct size. 1101 // 1102 // in particular, we want to make sure the clip (which is part 1103 // of the geometry state) is latched together with the size but is 1104 // latched immediately when no resizing is involved. 1105 // 1106 // If a sideband stream is attached, however, we want to skip this 1107 // optimization so that transactions aren't missed when a buffer 1108 // never arrives 1109 1110 flags |= eDontUpdateGeometryState; 1111 } 1112 } 1113 1114 // always set active to requested, unless we're asked not to 1115 // this is used by Layer, which special cases resizes. 1116 if (flags & eDontUpdateGeometryState) { 1117 } else { 1118 Layer::State& editCurrentState(getCurrentState()); 1119 editCurrentState.active = c.requested; 1120 } 1121 1122 if (s.active != c.active) { 1123 // invalidate and recompute the visible regions if needed 1124 flags |= Layer::eVisibleRegion; 1125 } 1126 1127 if (c.sequence != s.sequence) { 1128 // invalidate and recompute the visible regions if needed 1129 flags |= eVisibleRegion; 1130 this->contentDirty = true; 1131 1132 // we may use linear filtering, if the matrix scales us 1133 const uint8_t type = c.transform.getType(); 1134 mNeedsFiltering = (!c.transform.preserveRects() || 1135 (type >= Transform::SCALE)); 1136 } 1137 1138 // Commit the transaction 1139 commitTransaction(); 1140 return flags; 1141} 1142 1143void Layer::commitTransaction() { 1144 mDrawingState = mCurrentState; 1145} 1146 1147uint32_t Layer::getTransactionFlags(uint32_t flags) { 1148 return android_atomic_and(~flags, &mTransactionFlags) & flags; 1149} 1150 1151uint32_t Layer::setTransactionFlags(uint32_t flags) { 1152 return android_atomic_or(flags, &mTransactionFlags); 1153} 1154 1155bool Layer::setPosition(float x, float y) { 1156 if (mCurrentState.transform.tx() == x && mCurrentState.transform.ty() == y) 1157 return false; 1158 mCurrentState.sequence++; 1159 mCurrentState.transform.set(x, y); 1160 mCurrentState.modified = true; 1161 setTransactionFlags(eTransactionNeeded); 1162 return true; 1163} 1164bool Layer::setLayer(uint32_t z) { 1165 if (mCurrentState.z == z) 1166 return false; 1167 mCurrentState.sequence++; 1168 mCurrentState.z = z; 1169 mCurrentState.modified = true; 1170 setTransactionFlags(eTransactionNeeded); 1171 return true; 1172} 1173bool Layer::setSize(uint32_t w, uint32_t h) { 1174 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 1175 return false; 1176 mCurrentState.requested.w = w; 1177 mCurrentState.requested.h = h; 1178 mCurrentState.modified = true; 1179 setTransactionFlags(eTransactionNeeded); 1180 return true; 1181} 1182bool Layer::setAlpha(uint8_t alpha) { 1183 if (mCurrentState.alpha == alpha) 1184 return false; 1185 mCurrentState.sequence++; 1186 mCurrentState.alpha = alpha; 1187 mCurrentState.modified = true; 1188 setTransactionFlags(eTransactionNeeded); 1189 return true; 1190} 1191bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 1192 mCurrentState.sequence++; 1193 mCurrentState.transform.set( 1194 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); 1195 mCurrentState.modified = true; 1196 setTransactionFlags(eTransactionNeeded); 1197 return true; 1198} 1199bool Layer::setTransparentRegionHint(const Region& transparent) { 1200 mCurrentState.requestedTransparentRegion = transparent; 1201 mCurrentState.modified = true; 1202 setTransactionFlags(eTransactionNeeded); 1203 return true; 1204} 1205bool Layer::setFlags(uint8_t flags, uint8_t mask) { 1206 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 1207 if (mCurrentState.flags == newFlags) 1208 return false; 1209 mCurrentState.sequence++; 1210 mCurrentState.flags = newFlags; 1211 mCurrentState.mask = mask; 1212 mCurrentState.modified = true; 1213 setTransactionFlags(eTransactionNeeded); 1214 return true; 1215} 1216bool Layer::setCrop(const Rect& crop) { 1217 if (mCurrentState.requested.crop == crop) 1218 return false; 1219 mCurrentState.sequence++; 1220 mCurrentState.requested.crop = crop; 1221 mCurrentState.modified = true; 1222 setTransactionFlags(eTransactionNeeded); 1223 return true; 1224} 1225 1226bool Layer::setLayerStack(uint32_t layerStack) { 1227 if (mCurrentState.layerStack == layerStack) 1228 return false; 1229 mCurrentState.sequence++; 1230 mCurrentState.layerStack = layerStack; 1231 mCurrentState.modified = true; 1232 setTransactionFlags(eTransactionNeeded); 1233 return true; 1234} 1235 1236void Layer::deferTransactionUntil(const sp<IBinder>& handle, 1237 uint64_t frameNumber) { 1238 mCurrentState.handle = handle; 1239 mCurrentState.frameNumber = frameNumber; 1240 // We don't set eTransactionNeeded, because just receiving a deferral 1241 // request without any other state updates shouldn't actually induce a delay 1242 mCurrentState.modified = true; 1243 pushPendingState(); 1244 mCurrentState.handle = nullptr; 1245 mCurrentState.frameNumber = 0; 1246 mCurrentState.modified = false; 1247} 1248 1249void Layer::useSurfaceDamage() { 1250 if (mFlinger->mForceFullDamage) { 1251 surfaceDamageRegion = Region::INVALID_REGION; 1252 } else { 1253 surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage(); 1254 } 1255} 1256 1257void Layer::useEmptyDamage() { 1258 surfaceDamageRegion.clear(); 1259} 1260 1261// ---------------------------------------------------------------------------- 1262// pageflip handling... 1263// ---------------------------------------------------------------------------- 1264 1265bool Layer::shouldPresentNow(const DispSync& dispSync) const { 1266 if (mSidebandStreamChanged || mSingleBufferMode) { 1267 return true; 1268 } 1269 1270 Mutex::Autolock lock(mQueueItemLock); 1271 if (mQueueItems.empty()) { 1272 return false; 1273 } 1274 auto timestamp = mQueueItems[0].mTimestamp; 1275 nsecs_t expectedPresent = 1276 mSurfaceFlingerConsumer->computeExpectedPresent(dispSync); 1277 1278 // Ignore timestamps more than a second in the future 1279 bool isPlausible = timestamp < (expectedPresent + s2ns(1)); 1280 ALOGW_IF(!isPlausible, "[%s] Timestamp %" PRId64 " seems implausible " 1281 "relative to expectedPresent %" PRId64, mName.string(), timestamp, 1282 expectedPresent); 1283 1284 bool isDue = timestamp < expectedPresent; 1285 return isDue || !isPlausible; 1286} 1287 1288bool Layer::onPreComposition() { 1289 mRefreshPending = false; 1290 return mQueuedFrames > 0 || mSidebandStreamChanged || mSingleBufferMode; 1291} 1292 1293void Layer::onPostComposition() { 1294 if (mFrameLatencyNeeded) { 1295 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 1296 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 1297 1298 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 1299 if (frameReadyFence->isValid()) { 1300 mFrameTracker.setFrameReadyFence(frameReadyFence); 1301 } else { 1302 // There was no fence for this frame, so assume that it was ready 1303 // to be presented at the desired present time. 1304 mFrameTracker.setFrameReadyTime(desiredPresentTime); 1305 } 1306 1307 const HWComposer& hwc = mFlinger->getHwComposer(); 1308 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 1309 if (presentFence->isValid()) { 1310 mFrameTracker.setActualPresentFence(presentFence); 1311 } else { 1312 // The HWC doesn't support present fences, so use the refresh 1313 // timestamp instead. 1314 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 1315 mFrameTracker.setActualPresentTime(presentTime); 1316 } 1317 1318 mFrameTracker.advanceFrame(); 1319 mFrameLatencyNeeded = false; 1320 } 1321} 1322 1323bool Layer::isVisible() const { 1324 const Layer::State& s(mDrawingState); 1325 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha 1326 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1327} 1328 1329Region Layer::latchBuffer(bool& recomputeVisibleRegions) 1330{ 1331 ATRACE_CALL(); 1332 1333 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { 1334 // mSidebandStreamChanged was true 1335 mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream(); 1336 if (mSidebandStream != NULL) { 1337 setTransactionFlags(eTransactionNeeded); 1338 mFlinger->setTransactionFlags(eTraversalNeeded); 1339 } 1340 recomputeVisibleRegions = true; 1341 1342 const State& s(getDrawingState()); 1343 return s.transform.transform(Region(Rect(s.active.w, s.active.h))); 1344 } 1345 1346 Region outDirtyRegion; 1347 if (mQueuedFrames > 0 || mSingleBufferMode) { 1348 1349 // if we've already called updateTexImage() without going through 1350 // a composition step, we have to skip this layer at this point 1351 // because we cannot call updateTeximage() without a corresponding 1352 // compositionComplete() call. 1353 // we'll trigger an update in onPreComposition(). 1354 if (mRefreshPending) { 1355 return outDirtyRegion; 1356 } 1357 1358 // Capture the old state of the layer for comparisons later 1359 const State& s(getDrawingState()); 1360 const bool oldOpacity = isOpaque(s); 1361 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 1362 1363 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 1364 Layer::State& front; 1365 Layer::State& current; 1366 bool& recomputeVisibleRegions; 1367 bool stickyTransformSet; 1368 Reject(Layer::State& front, Layer::State& current, 1369 bool& recomputeVisibleRegions, bool stickySet) 1370 : front(front), current(current), 1371 recomputeVisibleRegions(recomputeVisibleRegions), 1372 stickyTransformSet(stickySet) { 1373 } 1374 1375 virtual bool reject(const sp<GraphicBuffer>& buf, 1376 const BufferItem& item) { 1377 if (buf == NULL) { 1378 return false; 1379 } 1380 1381 uint32_t bufWidth = buf->getWidth(); 1382 uint32_t bufHeight = buf->getHeight(); 1383 1384 // check that we received a buffer of the right size 1385 // (Take the buffer's orientation into account) 1386 if (item.mTransform & Transform::ROT_90) { 1387 swap(bufWidth, bufHeight); 1388 } 1389 1390 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1391 if (front.active != front.requested) { 1392 1393 if (isFixedSize || 1394 (bufWidth == front.requested.w && 1395 bufHeight == front.requested.h)) 1396 { 1397 // Here we pretend the transaction happened by updating the 1398 // current and drawing states. Drawing state is only accessed 1399 // in this thread, no need to have it locked 1400 front.active = front.requested; 1401 1402 // We also need to update the current state so that 1403 // we don't end-up overwriting the drawing state with 1404 // this stale current state during the next transaction 1405 // 1406 // NOTE: We don't need to hold the transaction lock here 1407 // because State::active is only accessed from this thread. 1408 current.active = front.active; 1409 1410 // recompute visible region 1411 recomputeVisibleRegions = true; 1412 } 1413 1414 ALOGD_IF(DEBUG_RESIZE, 1415 "latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 1416 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1417 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 1418 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 1419 front.active.w, front.active.h, 1420 front.active.crop.left, 1421 front.active.crop.top, 1422 front.active.crop.right, 1423 front.active.crop.bottom, 1424 front.active.crop.getWidth(), 1425 front.active.crop.getHeight(), 1426 front.requested.w, front.requested.h, 1427 front.requested.crop.left, 1428 front.requested.crop.top, 1429 front.requested.crop.right, 1430 front.requested.crop.bottom, 1431 front.requested.crop.getWidth(), 1432 front.requested.crop.getHeight()); 1433 } 1434 1435 if (!isFixedSize && !stickyTransformSet) { 1436 if (front.active.w != bufWidth || 1437 front.active.h != bufHeight) { 1438 // reject this buffer 1439 ALOGE("rejecting buffer: bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}", 1440 bufWidth, bufHeight, front.active.w, front.active.h); 1441 return true; 1442 } 1443 } 1444 1445 // if the transparent region has changed (this test is 1446 // conservative, but that's fine, worst case we're doing 1447 // a bit of extra work), we latch the new one and we 1448 // trigger a visible-region recompute. 1449 if (!front.activeTransparentRegion.isTriviallyEqual( 1450 front.requestedTransparentRegion)) { 1451 front.activeTransparentRegion = front.requestedTransparentRegion; 1452 1453 // We also need to update the current state so that 1454 // we don't end-up overwriting the drawing state with 1455 // this stale current state during the next transaction 1456 // 1457 // NOTE: We don't need to hold the transaction lock here 1458 // because State::active is only accessed from this thread. 1459 current.activeTransparentRegion = front.activeTransparentRegion; 1460 1461 // recompute visible region 1462 recomputeVisibleRegions = true; 1463 } 1464 1465 return false; 1466 } 1467 }; 1468 1469 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 1470 getProducerStickyTransform() != 0); 1471 1472 1473 // Check all of our local sync points to ensure that all transactions 1474 // which need to have been applied prior to the frame which is about to 1475 // be latched have signaled 1476 1477 auto headFrameNumber = getHeadFrameNumber(); 1478 bool matchingFramesFound = false; 1479 bool allTransactionsApplied = true; 1480 { 1481 Mutex::Autolock lock(mLocalSyncPointMutex); 1482 for (auto& point : mLocalSyncPoints) { 1483 if (point->getFrameNumber() > headFrameNumber) { 1484 break; 1485 } 1486 1487 matchingFramesFound = true; 1488 1489 if (!point->frameIsAvailable()) { 1490 // We haven't notified the remote layer that the frame for 1491 // this point is available yet. Notify it now, and then 1492 // abort this attempt to latch. 1493 point->setFrameAvailable(); 1494 allTransactionsApplied = false; 1495 break; 1496 } 1497 1498 allTransactionsApplied &= point->transactionIsApplied(); 1499 } 1500 } 1501 1502 if (matchingFramesFound && !allTransactionsApplied) { 1503 mFlinger->signalLayerUpdate(); 1504 return outDirtyRegion; 1505 } 1506 1507 // This boolean is used to make sure that SurfaceFlinger's shadow copy 1508 // of the buffer queue isn't modified when the buffer queue is returning 1509 // BufferItem's that weren't actually queued. This can happen in single 1510 // buffer mode. 1511 bool queuedBuffer = false; 1512 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, 1513 mFlinger->mPrimaryDispSync, &mSingleBufferMode, &queuedBuffer, 1514 mLastFrameNumberReceived); 1515 if (updateResult == BufferQueue::PRESENT_LATER) { 1516 // Producer doesn't want buffer to be displayed yet. Signal a 1517 // layer update so we check again at the next opportunity. 1518 mFlinger->signalLayerUpdate(); 1519 return outDirtyRegion; 1520 } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) { 1521 // If the buffer has been rejected, remove it from the shadow queue 1522 // and return early 1523 if (queuedBuffer) { 1524 Mutex::Autolock lock(mQueueItemLock); 1525 mQueueItems.removeAt(0); 1526 android_atomic_dec(&mQueuedFrames); 1527 } 1528 return outDirtyRegion; 1529 } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { 1530 // This can occur if something goes wrong when trying to create the 1531 // EGLImage for this buffer. If this happens, the buffer has already 1532 // been released, so we need to clean up the queue and bug out 1533 // early. 1534 if (queuedBuffer) { 1535 Mutex::Autolock lock(mQueueItemLock); 1536 mQueueItems.clear(); 1537 android_atomic_and(0, &mQueuedFrames); 1538 } 1539 1540 // Once we have hit this state, the shadow queue may no longer 1541 // correctly reflect the incoming BufferQueue's contents, so even if 1542 // updateTexImage starts working, the only safe course of action is 1543 // to continue to ignore updates. 1544 mUpdateTexImageFailed = true; 1545 1546 return outDirtyRegion; 1547 } 1548 1549 if (queuedBuffer) { 1550 // Autolock scope 1551 auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 1552 1553 Mutex::Autolock lock(mQueueItemLock); 1554 1555 // Remove any stale buffers that have been dropped during 1556 // updateTexImage 1557 while (mQueueItems[0].mFrameNumber != currentFrameNumber) { 1558 mQueueItems.removeAt(0); 1559 android_atomic_dec(&mQueuedFrames); 1560 } 1561 1562 mQueueItems.removeAt(0); 1563 } 1564 1565 1566 // Decrement the queued-frames count. Signal another event if we 1567 // have more frames pending. 1568 if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) 1569 || mSingleBufferMode) { 1570 mFlinger->signalLayerUpdate(); 1571 } 1572 1573 if (updateResult != NO_ERROR) { 1574 // something happened! 1575 recomputeVisibleRegions = true; 1576 return outDirtyRegion; 1577 } 1578 1579 // update the active buffer 1580 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 1581 if (mActiveBuffer == NULL) { 1582 // this can only happen if the very first buffer was rejected. 1583 return outDirtyRegion; 1584 } 1585 1586 mRefreshPending = true; 1587 mFrameLatencyNeeded = true; 1588 if (oldActiveBuffer == NULL) { 1589 // the first time we receive a buffer, we need to trigger a 1590 // geometry invalidation. 1591 recomputeVisibleRegions = true; 1592 } 1593 1594 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 1595 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 1596 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 1597 if ((crop != mCurrentCrop) || 1598 (transform != mCurrentTransform) || 1599 (scalingMode != mCurrentScalingMode)) 1600 { 1601 mCurrentCrop = crop; 1602 mCurrentTransform = transform; 1603 mCurrentScalingMode = scalingMode; 1604 recomputeVisibleRegions = true; 1605 } 1606 1607 if (oldActiveBuffer != NULL) { 1608 uint32_t bufWidth = mActiveBuffer->getWidth(); 1609 uint32_t bufHeight = mActiveBuffer->getHeight(); 1610 if (bufWidth != uint32_t(oldActiveBuffer->width) || 1611 bufHeight != uint32_t(oldActiveBuffer->height)) { 1612 recomputeVisibleRegions = true; 1613 } 1614 } 1615 1616 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 1617 if (oldOpacity != isOpaque(s)) { 1618 recomputeVisibleRegions = true; 1619 } 1620 1621 mCurrentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 1622 1623 // Remove any sync points corresponding to the buffer which was just 1624 // latched 1625 { 1626 Mutex::Autolock lock(mLocalSyncPointMutex); 1627 auto point = mLocalSyncPoints.begin(); 1628 while (point != mLocalSyncPoints.end()) { 1629 if (!(*point)->frameIsAvailable() || 1630 !(*point)->transactionIsApplied()) { 1631 // This sync point must have been added since we started 1632 // latching. Don't drop it yet. 1633 ++point; 1634 continue; 1635 } 1636 1637 if ((*point)->getFrameNumber() <= mCurrentFrameNumber) { 1638 point = mLocalSyncPoints.erase(point); 1639 } else { 1640 ++point; 1641 } 1642 } 1643 } 1644 1645 // FIXME: postedRegion should be dirty & bounds 1646 Region dirtyRegion(Rect(s.active.w, s.active.h)); 1647 1648 // transform the dirty region to window-manager space 1649 outDirtyRegion = (s.transform.transform(dirtyRegion)); 1650 } 1651 return outDirtyRegion; 1652} 1653 1654uint32_t Layer::getEffectiveUsage(uint32_t usage) const 1655{ 1656 // TODO: should we do something special if mSecure is set? 1657 if (mProtectedByApp) { 1658 // need a hardware-protected path to external video sink 1659 usage |= GraphicBuffer::USAGE_PROTECTED; 1660 } 1661 if (mPotentialCursor) { 1662 usage |= GraphicBuffer::USAGE_CURSOR; 1663 } 1664 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 1665 return usage; 1666} 1667 1668void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 1669 uint32_t orientation = 0; 1670 if (!mFlinger->mDebugDisableTransformHint) { 1671 // The transform hint is used to improve performance, but we can 1672 // only have a single transform hint, it cannot 1673 // apply to all displays. 1674 const Transform& planeTransform(hw->getTransform()); 1675 orientation = planeTransform.getOrientation(); 1676 if (orientation & Transform::ROT_INVALID) { 1677 orientation = 0; 1678 } 1679 } 1680 mSurfaceFlingerConsumer->setTransformHint(orientation); 1681} 1682 1683// ---------------------------------------------------------------------------- 1684// debugging 1685// ---------------------------------------------------------------------------- 1686 1687void Layer::dump(String8& result, Colorizer& colorizer) const 1688{ 1689 const Layer::State& s(getDrawingState()); 1690 1691 colorizer.colorize(result, Colorizer::GREEN); 1692 result.appendFormat( 1693 "+ %s %p (%s)\n", 1694 getTypeId(), this, getName().string()); 1695 colorizer.reset(result); 1696 1697 s.activeTransparentRegion.dump(result, "transparentRegion"); 1698 visibleRegion.dump(result, "visibleRegion"); 1699 surfaceDamageRegion.dump(result, "surfaceDamageRegion"); 1700 sp<Client> client(mClientRef.promote()); 1701 1702 result.appendFormat( " " 1703 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), " 1704 "isOpaque=%1d, invalidate=%1d, " 1705 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 1706 " client=%p\n", 1707 s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h, 1708 s.active.crop.left, s.active.crop.top, 1709 s.active.crop.right, s.active.crop.bottom, 1710 isOpaque(s), contentDirty, 1711 s.alpha, s.flags, 1712 s.transform[0][0], s.transform[0][1], 1713 s.transform[1][0], s.transform[1][1], 1714 client.get()); 1715 1716 sp<const GraphicBuffer> buf0(mActiveBuffer); 1717 uint32_t w0=0, h0=0, s0=0, f0=0; 1718 if (buf0 != 0) { 1719 w0 = buf0->getWidth(); 1720 h0 = buf0->getHeight(); 1721 s0 = buf0->getStride(); 1722 f0 = buf0->format; 1723 } 1724 result.appendFormat( 1725 " " 1726 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 1727 " queued-frames=%d, mRefreshPending=%d\n", 1728 mFormat, w0, h0, s0,f0, 1729 mQueuedFrames, mRefreshPending); 1730 1731 if (mSurfaceFlingerConsumer != 0) { 1732 mSurfaceFlingerConsumer->dump(result, " "); 1733 } 1734} 1735 1736void Layer::dumpFrameStats(String8& result) const { 1737 mFrameTracker.dumpStats(result); 1738} 1739 1740void Layer::clearFrameStats() { 1741 mFrameTracker.clearStats(); 1742} 1743 1744void Layer::logFrameStats() { 1745 mFrameTracker.logAndResetStats(mName); 1746} 1747 1748void Layer::getFrameStats(FrameStats* outStats) const { 1749 mFrameTracker.getStats(outStats); 1750} 1751 1752// --------------------------------------------------------------------------- 1753 1754Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 1755 const sp<Layer>& layer) 1756 : mFlinger(flinger), mLayer(layer) { 1757} 1758 1759Layer::LayerCleaner::~LayerCleaner() { 1760 // destroy client resources 1761 mFlinger->onLayerDestroyed(mLayer); 1762} 1763 1764// --------------------------------------------------------------------------- 1765}; // namespace android 1766 1767#if defined(__gl_h_) 1768#error "don't include gl/gl.h in this file" 1769#endif 1770 1771#if defined(__gl2_h_) 1772#error "don't include gl2/gl2.h in this file" 1773#endif 1774