Layer.cpp revision 595264f1af12e25dce57d7c5b1d52ed86ac0d0c9
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/StopWatch.h> 31#include <utils/Trace.h> 32 33#include <ui/GraphicBuffer.h> 34#include <ui/PixelFormat.h> 35 36#include <gui/Surface.h> 37 38#include "clz.h" 39#include "Colorizer.h" 40#include "DisplayDevice.h" 41#include "Layer.h" 42#include "SurfaceFlinger.h" 43#include "SurfaceTextureLayer.h" 44 45#include "DisplayHardware/HWComposer.h" 46 47#include "RenderEngine/RenderEngine.h" 48 49#define DEBUG_RESIZE 0 50 51namespace android { 52 53// --------------------------------------------------------------------------- 54 55int32_t Layer::sSequence = 1; 56 57Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client, 58 const String8& name, uint32_t w, uint32_t h, uint32_t flags) 59 : contentDirty(false), 60 sequence(uint32_t(android_atomic_inc(&sSequence))), 61 mFlinger(flinger), 62 mTextureName(-1U), 63 mPremultipliedAlpha(true), 64 mName("unnamed"), 65 mDebug(false), 66 mFormat(PIXEL_FORMAT_NONE), 67 mOpaqueLayer(true), 68 mTransactionFlags(0), 69 mQueuedFrames(0), 70 mCurrentTransform(0), 71 mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), 72 mCurrentOpacity(true), 73 mRefreshPending(false), 74 mFrameLatencyNeeded(false), 75 mFiltering(false), 76 mNeedsFiltering(false), 77 mSecure(false), 78 mProtectedByApp(false), 79 mHasSurface(false), 80 mClientRef(client) 81{ 82 mCurrentCrop.makeInvalid(); 83 glGenTextures(1, &mTextureName); 84 85 uint32_t layerFlags = 0; 86 if (flags & ISurfaceComposerClient::eHidden) 87 layerFlags = layer_state_t::eLayerHidden; 88 89 if (flags & ISurfaceComposerClient::eNonPremultiplied) 90 mPremultipliedAlpha = false; 91 92 mName = name; 93 94 mCurrentState.active.w = w; 95 mCurrentState.active.h = h; 96 mCurrentState.active.crop.makeInvalid(); 97 mCurrentState.z = 0; 98 mCurrentState.alpha = 0xFF; 99 mCurrentState.layerStack = 0; 100 mCurrentState.flags = layerFlags; 101 mCurrentState.sequence = 0; 102 mCurrentState.transform.set(0, 0); 103 mCurrentState.requested = mCurrentState.active; 104 105 // drawing state & current state are identical 106 mDrawingState = mCurrentState; 107} 108 109void Layer::onFirstRef() 110{ 111 // Creates a custom BufferQueue for SurfaceFlingerConsumer to use 112 sp<BufferQueue> bq = new SurfaceTextureLayer(mFlinger); 113 mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(bq, mTextureName, 114 GL_TEXTURE_EXTERNAL_OES, false); 115 116 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 117 mSurfaceFlingerConsumer->setFrameAvailableListener(this); 118 mSurfaceFlingerConsumer->setName(mName); 119 120#ifdef TARGET_DISABLE_TRIPLE_BUFFERING 121#warning "disabling triple buffering" 122 mSurfaceFlingerConsumer->setDefaultMaxBufferCount(2); 123#else 124 mSurfaceFlingerConsumer->setDefaultMaxBufferCount(3); 125#endif 126 127 const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); 128 updateTransformHint(hw); 129} 130 131Layer::~Layer() { 132 sp<Client> c(mClientRef.promote()); 133 if (c != 0) { 134 c->detachLayer(this); 135 } 136 mFlinger->deleteTextureAsync(mTextureName); 137} 138 139// --------------------------------------------------------------------------- 140// callbacks 141// --------------------------------------------------------------------------- 142 143void Layer::onLayerDisplayed(const sp<const DisplayDevice>& hw, 144 HWComposer::HWCLayerInterface* layer) { 145 if (layer) { 146 layer->onDisplayed(); 147 mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFence()); 148 } 149} 150 151void Layer::onFrameAvailable() { 152 android_atomic_inc(&mQueuedFrames); 153 mFlinger->signalLayerUpdate(); 154} 155 156// called with SurfaceFlinger::mStateLock from the drawing thread after 157// the layer has been remove from the current state list (and just before 158// it's removed from the drawing state list) 159void Layer::onRemoved() { 160 mSurfaceFlingerConsumer->abandon(); 161} 162 163// --------------------------------------------------------------------------- 164// set-up 165// --------------------------------------------------------------------------- 166 167const String8& Layer::getName() const { 168 return mName; 169} 170 171status_t Layer::setBuffers( uint32_t w, uint32_t h, 172 PixelFormat format, uint32_t flags) 173{ 174 // this surfaces pixel format 175 PixelFormatInfo info; 176 status_t err = getPixelFormatInfo(format, &info); 177 if (err) { 178 ALOGE("unsupported pixelformat %d", format); 179 return err; 180 } 181 182 uint32_t const maxSurfaceDims = min( 183 mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); 184 185 // never allow a surface larger than what our underlying GL implementation 186 // can handle. 187 if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) { 188 ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); 189 return BAD_VALUE; 190 } 191 192 mFormat = format; 193 194 mSecure = (flags & ISurfaceComposerClient::eSecure) ? true : false; 195 mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; 196 mOpaqueLayer = (flags & ISurfaceComposerClient::eOpaque); 197 mCurrentOpacity = getOpacityForFormat(format); 198 199 mSurfaceFlingerConsumer->setDefaultBufferSize(w, h); 200 mSurfaceFlingerConsumer->setDefaultBufferFormat(format); 201 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 202 203 return NO_ERROR; 204} 205 206sp<IBinder> Layer::getHandle() { 207 Mutex::Autolock _l(mLock); 208 209 LOG_ALWAYS_FATAL_IF(mHasSurface, 210 "Layer::getHandle() has already been called"); 211 212 mHasSurface = true; 213 214 /* 215 * The layer handle is just a BBinder object passed to the client 216 * (remote process) -- we don't keep any reference on our side such that 217 * the dtor is called when the remote side let go of its reference. 218 * 219 * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for 220 * this layer when the handle is destroyed. 221 */ 222 223 class Handle : public BBinder, public LayerCleaner { 224 wp<const Layer> mOwner; 225 public: 226 Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer) 227 : LayerCleaner(flinger, layer), mOwner(layer) { 228 } 229 }; 230 231 return new Handle(mFlinger, this); 232} 233 234sp<BufferQueue> Layer::getBufferQueue() const { 235 return mSurfaceFlingerConsumer->getBufferQueue(); 236} 237 238// --------------------------------------------------------------------------- 239// h/w composer set-up 240// --------------------------------------------------------------------------- 241 242Rect Layer::getContentCrop() const { 243 // this is the crop rectangle that applies to the buffer 244 // itself (as opposed to the window) 245 Rect crop; 246 if (!mCurrentCrop.isEmpty()) { 247 // if the buffer crop is defined, we use that 248 crop = mCurrentCrop; 249 } else if (mActiveBuffer != NULL) { 250 // otherwise we use the whole buffer 251 crop = mActiveBuffer->getBounds(); 252 } else { 253 // if we don't have a buffer yet, we use an empty/invalid crop 254 crop.makeInvalid(); 255 } 256 return crop; 257} 258 259static Rect reduce(const Rect& win, const Region& exclude) { 260 if (CC_LIKELY(exclude.isEmpty())) { 261 return win; 262 } 263 if (exclude.isRect()) { 264 return win.reduce(exclude.getBounds()); 265 } 266 return Region(win).subtract(exclude).getBounds(); 267} 268 269Rect Layer::computeBounds() const { 270 const Layer::State& s(getDrawingState()); 271 Rect win(s.active.w, s.active.h); 272 if (!s.active.crop.isEmpty()) { 273 win.intersect(s.active.crop, &win); 274 } 275 // subtract the transparent region and snap to the bounds 276 return reduce(win, s.activeTransparentRegion); 277} 278 279FloatRect Layer::computeCrop(const sp<const DisplayDevice>& hw) const { 280 // the content crop is the area of the content that gets scaled to the 281 // layer's size. 282 FloatRect crop(getContentCrop()); 283 284 // the active.crop is the area of the window that gets cropped, but not 285 // scaled in any ways. 286 const State& s(getDrawingState()); 287 288 // apply the projection's clipping to the window crop in 289 // layerstack space, and convert-back to layer space. 290 // if there are no window scaling involved, this operation will map to full 291 // pixels in the buffer. 292 // FIXME: the 3 lines below can produce slightly incorrect clipping when we have 293 // a viewport clipping and a window transform. we should use floating point to fix this. 294 Rect activeCrop(s.transform.transform(s.active.crop)); 295 activeCrop.intersect(hw->getViewport(), &activeCrop); 296 activeCrop = s.transform.inverse().transform(activeCrop); 297 298 // paranoia: make sure the window-crop is constrained in the 299 // window's bounds 300 activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop); 301 302 // subtract the transparent region and snap to the bounds 303 activeCrop = reduce(activeCrop, s.activeTransparentRegion); 304 305 if (!activeCrop.isEmpty()) { 306 // Transform the window crop to match the buffer coordinate system, 307 // which means using the inverse of the current transform set on the 308 // SurfaceFlingerConsumer. 309 uint32_t invTransform = mCurrentTransform; 310 int winWidth = s.active.w; 311 int winHeight = s.active.h; 312 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 313 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 314 NATIVE_WINDOW_TRANSFORM_FLIP_H; 315 winWidth = s.active.h; 316 winHeight = s.active.w; 317 } 318 const Rect winCrop = activeCrop.transform( 319 invTransform, s.active.w, s.active.h); 320 321 // below, crop is intersected with winCrop expressed in crop's coordinate space 322 float xScale = crop.getWidth() / float(winWidth); 323 float yScale = crop.getHeight() / float(winHeight); 324 325 float insetL = winCrop.left * xScale; 326 float insetT = winCrop.top * yScale; 327 float insetR = (winWidth - winCrop.right ) * xScale; 328 float insetB = (winHeight - winCrop.bottom) * yScale; 329 330 crop.left += insetL; 331 crop.top += insetT; 332 crop.right -= insetR; 333 crop.bottom -= insetB; 334 } 335 return crop; 336} 337 338void Layer::setGeometry( 339 const sp<const DisplayDevice>& hw, 340 HWComposer::HWCLayerInterface& layer) 341{ 342 layer.setDefaultState(); 343 344 // enable this layer 345 layer.setSkip(false); 346 347 if (isSecure() && !hw->isSecure()) { 348 layer.setSkip(true); 349 } 350 351 // this gives us only the "orientation" component of the transform 352 const State& s(getDrawingState()); 353 if (!isOpaque() || s.alpha != 0xFF) { 354 layer.setBlending(mPremultipliedAlpha ? 355 HWC_BLENDING_PREMULT : 356 HWC_BLENDING_COVERAGE); 357 } 358 359 // apply the layer's transform, followed by the display's global transform 360 // here we're guaranteed that the layer's transform preserves rects 361 Rect frame(s.transform.transform(computeBounds())); 362 frame.intersect(hw->getViewport(), &frame); 363 const Transform& tr(hw->getTransform()); 364 layer.setFrame(tr.transform(frame)); 365 layer.setCrop(computeCrop(hw)); 366 layer.setPlaneAlpha(s.alpha); 367 368 /* 369 * Transformations are applied in this order: 370 * 1) buffer orientation/flip/mirror 371 * 2) state transformation (window manager) 372 * 3) layer orientation (screen orientation) 373 * (NOTE: the matrices are multiplied in reverse order) 374 */ 375 376 const Transform bufferOrientation(mCurrentTransform); 377 const Transform transform(tr * s.transform * bufferOrientation); 378 379 // this gives us only the "orientation" component of the transform 380 const uint32_t orientation = transform.getOrientation(); 381 if (orientation & Transform::ROT_INVALID) { 382 // we can only handle simple transformation 383 layer.setSkip(true); 384 } else { 385 layer.setTransform(orientation); 386 } 387} 388 389void Layer::setPerFrameData(const sp<const DisplayDevice>& hw, 390 HWComposer::HWCLayerInterface& layer) { 391 // we have to set the visible region on every frame because 392 // we currently free it during onLayerDisplayed(), which is called 393 // after HWComposer::commit() -- every frame. 394 // Apply this display's projection's viewport to the visible region 395 // before giving it to the HWC HAL. 396 const Transform& tr = hw->getTransform(); 397 Region visible = tr.transform(visibleRegion.intersect(hw->getViewport())); 398 layer.setVisibleRegionScreen(visible); 399 400 // NOTE: buffer can be NULL if the client never drew into this 401 // layer yet, or if we ran out of memory 402 layer.setBuffer(mActiveBuffer); 403} 404 405void Layer::setAcquireFence(const sp<const DisplayDevice>& hw, 406 HWComposer::HWCLayerInterface& layer) { 407 int fenceFd = -1; 408 409 // TODO: there is a possible optimization here: we only need to set the 410 // acquire fence the first time a new buffer is acquired on EACH display. 411 412 if (layer.getCompositionType() == HWC_OVERLAY) { 413 sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence(); 414 if (fence->isValid()) { 415 fenceFd = fence->dup(); 416 if (fenceFd == -1) { 417 ALOGW("failed to dup layer fence, skipping sync: %d", errno); 418 } 419 } 420 } 421 layer.setAcquireFenceFd(fenceFd); 422} 423 424// --------------------------------------------------------------------------- 425// drawing... 426// --------------------------------------------------------------------------- 427 428void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const { 429 onDraw(hw, clip); 430} 431 432void Layer::draw(const sp<const DisplayDevice>& hw) { 433 onDraw( hw, Region(hw->bounds()) ); 434} 435 436void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip) const 437{ 438 ATRACE_CALL(); 439 440 if (CC_UNLIKELY(mActiveBuffer == 0)) { 441 // the texture has not been created yet, this Layer has 442 // in fact never been drawn into. This happens frequently with 443 // SurfaceView because the WindowManager can't know when the client 444 // has drawn the first time. 445 446 // If there is nothing under us, we paint the screen in black, otherwise 447 // we just skip this update. 448 449 // figure out if there is something below us 450 Region under; 451 const SurfaceFlinger::LayerVector& drawingLayers( 452 mFlinger->mDrawingState.layersSortedByZ); 453 const size_t count = drawingLayers.size(); 454 for (size_t i=0 ; i<count ; ++i) { 455 const sp<Layer>& layer(drawingLayers[i]); 456 if (layer.get() == static_cast<Layer const*>(this)) 457 break; 458 under.orSelf( hw->getTransform().transform(layer->visibleRegion) ); 459 } 460 // if not everything below us is covered, we plug the holes! 461 Region holes(clip.subtract(under)); 462 if (!holes.isEmpty()) { 463 clearWithOpenGL(hw, holes, 0, 0, 0, 1); 464 } 465 return; 466 } 467 468 // Bind the current buffer to the GL texture, and wait for it to be 469 // ready for us to draw into. 470 status_t err = mSurfaceFlingerConsumer->bindTextureImage(); 471 if (err != NO_ERROR) { 472 ALOGW("onDraw: bindTextureImage failed (err=%d)", err); 473 // Go ahead and draw the buffer anyway; no matter what we do the screen 474 // is probably going to have something visibly wrong. 475 } 476 477 bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure()); 478 479 RenderEngine& engine(mFlinger->getRenderEngine()); 480 481 if (!blackOutLayer) { 482 // TODO: we could be more subtle with isFixedSize() 483 const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize(); 484 485 // Query the texture matrix given our current filtering mode. 486 float textureMatrix[16]; 487 mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering); 488 mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix); 489 490 // Set things up for texturing. 491 engine.setupLayerTexturing(mTextureName, useFiltering, textureMatrix); 492 } else { 493 engine.setupLayerBlackedOut(); 494 } 495 drawWithOpenGL(hw, clip); 496 engine.disableTexturing(); 497} 498 499 500void Layer::clearWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip, 501 GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) const 502{ 503 LayerMesh mesh; 504 computeGeometry(hw, &mesh); 505 506 mFlinger->getRenderEngine().clearWithColor( 507 mesh.getVertices(), mesh.getVertexCount(), 508 red, green, blue, alpha); 509} 510 511void Layer::clearWithOpenGL( 512 const sp<const DisplayDevice>& hw, const Region& clip) const { 513 clearWithOpenGL(hw, clip, 0,0,0,0); 514} 515 516void Layer::drawWithOpenGL( 517 const sp<const DisplayDevice>& hw, const Region& clip) const { 518 const uint32_t fbHeight = hw->getHeight(); 519 const State& s(getDrawingState()); 520 521 LayerMesh mesh; 522 computeGeometry(hw, &mesh); 523 524 /* 525 * NOTE: the way we compute the texture coordinates here produces 526 * different results than when we take the HWC path -- in the later case 527 * the "source crop" is rounded to texel boundaries. 528 * This can produce significantly different results when the texture 529 * is scaled by a large amount. 530 * 531 * The GL code below is more logical (imho), and the difference with 532 * HWC is due to a limitation of the HWC API to integers -- a question 533 * is suspend is wether we should ignore this problem or revert to 534 * GL composition when a buffer scaling is applied (maybe with some 535 * minimal value)? Or, we could make GL behave like HWC -- but this feel 536 * like more of a hack. 537 */ 538 const Rect win(computeBounds()); 539 540 GLfloat left = GLfloat(win.left) / GLfloat(s.active.w); 541 GLfloat top = GLfloat(win.top) / GLfloat(s.active.h); 542 GLfloat right = GLfloat(win.right) / GLfloat(s.active.w); 543 GLfloat bottom = GLfloat(win.bottom) / GLfloat(s.active.h); 544 545 // TODO: we probably want to generate the texture coords with the mesh 546 // here we assume that we only have 4 vertices 547 float texCoords[4][2]; 548 texCoords[0][0] = left; 549 texCoords[0][1] = top; 550 texCoords[1][0] = left; 551 texCoords[1][1] = bottom; 552 texCoords[2][0] = right; 553 texCoords[2][1] = bottom; 554 texCoords[3][0] = right; 555 texCoords[3][1] = top; 556 for (int i = 0; i < 4; i++) { 557 texCoords[i][1] = 1.0f - texCoords[i][1]; 558 } 559 560 RenderEngine& engine(mFlinger->getRenderEngine()); 561 engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(), s.alpha); 562 engine.drawMesh2D(mesh.getVertices(), texCoords, mesh.getVertexCount()); 563 engine.disableBlending(); 564} 565 566void Layer::setFiltering(bool filtering) { 567 mFiltering = filtering; 568} 569 570bool Layer::getFiltering() const { 571 return mFiltering; 572} 573 574// As documented in libhardware header, formats in the range 575// 0x100 - 0x1FF are specific to the HAL implementation, and 576// are known to have no alpha channel 577// TODO: move definition for device-specific range into 578// hardware.h, instead of using hard-coded values here. 579#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) 580 581bool Layer::getOpacityForFormat(uint32_t format) 582{ 583 if (HARDWARE_IS_DEVICE_FORMAT(format)) { 584 return true; 585 } 586 PixelFormatInfo info; 587 status_t err = getPixelFormatInfo(PixelFormat(format), &info); 588 // in case of error (unknown format), we assume no blending 589 return (err || info.h_alpha <= info.l_alpha); 590} 591 592// ---------------------------------------------------------------------------- 593// local state 594// ---------------------------------------------------------------------------- 595 596void Layer::computeGeometry(const sp<const DisplayDevice>& hw, LayerMesh* mesh) const 597{ 598 const Layer::State& s(getDrawingState()); 599 const Transform tr(hw->getTransform() * s.transform); 600 const uint32_t hw_h = hw->getHeight(); 601 Rect win(s.active.w, s.active.h); 602 if (!s.active.crop.isEmpty()) { 603 win.intersect(s.active.crop, &win); 604 } 605 // subtract the transparent region and snap to the bounds 606 win = reduce(win, s.activeTransparentRegion); 607 if (mesh) { 608 tr.transform(mesh->mVertices[0], win.left, win.top); 609 tr.transform(mesh->mVertices[1], win.left, win.bottom); 610 tr.transform(mesh->mVertices[2], win.right, win.bottom); 611 tr.transform(mesh->mVertices[3], win.right, win.top); 612 for (size_t i=0 ; i<4 ; i++) { 613 mesh->mVertices[i][1] = hw_h - mesh->mVertices[i][1]; 614 } 615 } 616} 617 618bool Layer::isOpaque() const 619{ 620 // if we don't have a buffer yet, we're translucent regardless of the 621 // layer's opaque flag. 622 if (mActiveBuffer == 0) { 623 return false; 624 } 625 626 // if the layer has the opaque flag, then we're always opaque, 627 // otherwise we use the current buffer's format. 628 return mOpaqueLayer || mCurrentOpacity; 629} 630 631bool Layer::isProtected() const 632{ 633 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 634 return (activeBuffer != 0) && 635 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 636} 637 638bool Layer::isFixedSize() const { 639 return mCurrentScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 640} 641 642bool Layer::isCropped() const { 643 return !mCurrentCrop.isEmpty(); 644} 645 646bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const { 647 return mNeedsFiltering || hw->needsFiltering(); 648} 649 650void Layer::setVisibleRegion(const Region& visibleRegion) { 651 // always called from main thread 652 this->visibleRegion = visibleRegion; 653} 654 655void Layer::setCoveredRegion(const Region& coveredRegion) { 656 // always called from main thread 657 this->coveredRegion = coveredRegion; 658} 659 660void Layer::setVisibleNonTransparentRegion(const Region& 661 setVisibleNonTransparentRegion) { 662 // always called from main thread 663 this->visibleNonTransparentRegion = setVisibleNonTransparentRegion; 664} 665 666// ---------------------------------------------------------------------------- 667// transaction 668// ---------------------------------------------------------------------------- 669 670uint32_t Layer::doTransaction(uint32_t flags) { 671 ATRACE_CALL(); 672 673 const Layer::State& s(getDrawingState()); 674 const Layer::State& c(getCurrentState()); 675 676 const bool sizeChanged = (c.requested.w != s.requested.w) || 677 (c.requested.h != s.requested.h); 678 679 if (sizeChanged) { 680 // the size changed, we need to ask our client to request a new buffer 681 ALOGD_IF(DEBUG_RESIZE, 682 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 683 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 684 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n" 685 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 686 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 687 this, getName().string(), mCurrentTransform, mCurrentScalingMode, 688 c.active.w, c.active.h, 689 c.active.crop.left, 690 c.active.crop.top, 691 c.active.crop.right, 692 c.active.crop.bottom, 693 c.active.crop.getWidth(), 694 c.active.crop.getHeight(), 695 c.requested.w, c.requested.h, 696 c.requested.crop.left, 697 c.requested.crop.top, 698 c.requested.crop.right, 699 c.requested.crop.bottom, 700 c.requested.crop.getWidth(), 701 c.requested.crop.getHeight(), 702 s.active.w, s.active.h, 703 s.active.crop.left, 704 s.active.crop.top, 705 s.active.crop.right, 706 s.active.crop.bottom, 707 s.active.crop.getWidth(), 708 s.active.crop.getHeight(), 709 s.requested.w, s.requested.h, 710 s.requested.crop.left, 711 s.requested.crop.top, 712 s.requested.crop.right, 713 s.requested.crop.bottom, 714 s.requested.crop.getWidth(), 715 s.requested.crop.getHeight()); 716 717 // record the new size, form this point on, when the client request 718 // a buffer, it'll get the new size. 719 mSurfaceFlingerConsumer->setDefaultBufferSize( 720 c.requested.w, c.requested.h); 721 } 722 723 if (!isFixedSize()) { 724 725 const bool resizePending = (c.requested.w != c.active.w) || 726 (c.requested.h != c.active.h); 727 728 if (resizePending) { 729 // don't let Layer::doTransaction update the drawing state 730 // if we have a pending resize, unless we are in fixed-size mode. 731 // the drawing state will be updated only once we receive a buffer 732 // with the correct size. 733 // 734 // in particular, we want to make sure the clip (which is part 735 // of the geometry state) is latched together with the size but is 736 // latched immediately when no resizing is involved. 737 738 flags |= eDontUpdateGeometryState; 739 } 740 } 741 742 // always set active to requested, unless we're asked not to 743 // this is used by Layer, which special cases resizes. 744 if (flags & eDontUpdateGeometryState) { 745 } else { 746 Layer::State& editCurrentState(getCurrentState()); 747 editCurrentState.active = c.requested; 748 } 749 750 if (s.active != c.active) { 751 // invalidate and recompute the visible regions if needed 752 flags |= Layer::eVisibleRegion; 753 } 754 755 if (c.sequence != s.sequence) { 756 // invalidate and recompute the visible regions if needed 757 flags |= eVisibleRegion; 758 this->contentDirty = true; 759 760 // we may use linear filtering, if the matrix scales us 761 const uint8_t type = c.transform.getType(); 762 mNeedsFiltering = (!c.transform.preserveRects() || 763 (type >= Transform::SCALE)); 764 } 765 766 // Commit the transaction 767 commitTransaction(); 768 return flags; 769} 770 771void Layer::commitTransaction() { 772 mDrawingState = mCurrentState; 773} 774 775uint32_t Layer::getTransactionFlags(uint32_t flags) { 776 return android_atomic_and(~flags, &mTransactionFlags) & flags; 777} 778 779uint32_t Layer::setTransactionFlags(uint32_t flags) { 780 return android_atomic_or(flags, &mTransactionFlags); 781} 782 783bool Layer::setPosition(float x, float y) { 784 if (mCurrentState.transform.tx() == x && mCurrentState.transform.ty() == y) 785 return false; 786 mCurrentState.sequence++; 787 mCurrentState.transform.set(x, y); 788 setTransactionFlags(eTransactionNeeded); 789 return true; 790} 791bool Layer::setLayer(uint32_t z) { 792 if (mCurrentState.z == z) 793 return false; 794 mCurrentState.sequence++; 795 mCurrentState.z = z; 796 setTransactionFlags(eTransactionNeeded); 797 return true; 798} 799bool Layer::setSize(uint32_t w, uint32_t h) { 800 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 801 return false; 802 mCurrentState.requested.w = w; 803 mCurrentState.requested.h = h; 804 setTransactionFlags(eTransactionNeeded); 805 return true; 806} 807bool Layer::setAlpha(uint8_t alpha) { 808 if (mCurrentState.alpha == alpha) 809 return false; 810 mCurrentState.sequence++; 811 mCurrentState.alpha = alpha; 812 setTransactionFlags(eTransactionNeeded); 813 return true; 814} 815bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 816 mCurrentState.sequence++; 817 mCurrentState.transform.set( 818 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); 819 setTransactionFlags(eTransactionNeeded); 820 return true; 821} 822bool Layer::setTransparentRegionHint(const Region& transparent) { 823 mCurrentState.requestedTransparentRegion = transparent; 824 setTransactionFlags(eTransactionNeeded); 825 return true; 826} 827bool Layer::setFlags(uint8_t flags, uint8_t mask) { 828 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 829 if (mCurrentState.flags == newFlags) 830 return false; 831 mCurrentState.sequence++; 832 mCurrentState.flags = newFlags; 833 setTransactionFlags(eTransactionNeeded); 834 return true; 835} 836bool Layer::setCrop(const Rect& crop) { 837 if (mCurrentState.requested.crop == crop) 838 return false; 839 mCurrentState.sequence++; 840 mCurrentState.requested.crop = crop; 841 setTransactionFlags(eTransactionNeeded); 842 return true; 843} 844 845bool Layer::setLayerStack(uint32_t layerStack) { 846 if (mCurrentState.layerStack == layerStack) 847 return false; 848 mCurrentState.sequence++; 849 mCurrentState.layerStack = layerStack; 850 setTransactionFlags(eTransactionNeeded); 851 return true; 852} 853 854// ---------------------------------------------------------------------------- 855// pageflip handling... 856// ---------------------------------------------------------------------------- 857 858bool Layer::onPreComposition() { 859 mRefreshPending = false; 860 return mQueuedFrames > 0; 861} 862 863void Layer::onPostComposition() { 864 if (mFrameLatencyNeeded) { 865 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 866 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 867 868 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 869 if (frameReadyFence->isValid()) { 870 mFrameTracker.setFrameReadyFence(frameReadyFence); 871 } else { 872 // There was no fence for this frame, so assume that it was ready 873 // to be presented at the desired present time. 874 mFrameTracker.setFrameReadyTime(desiredPresentTime); 875 } 876 877 const HWComposer& hwc = mFlinger->getHwComposer(); 878 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 879 if (presentFence->isValid()) { 880 mFrameTracker.setActualPresentFence(presentFence); 881 } else { 882 // The HWC doesn't support present fences, so use the refresh 883 // timestamp instead. 884 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 885 mFrameTracker.setActualPresentTime(presentTime); 886 } 887 888 mFrameTracker.advanceFrame(); 889 mFrameLatencyNeeded = false; 890 } 891} 892 893bool Layer::isVisible() const { 894 const Layer::State& s(mDrawingState); 895 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha 896 && (mActiveBuffer != NULL); 897} 898 899Region Layer::latchBuffer(bool& recomputeVisibleRegions) 900{ 901 ATRACE_CALL(); 902 903 Region outDirtyRegion; 904 if (mQueuedFrames > 0) { 905 906 // if we've already called updateTexImage() without going through 907 // a composition step, we have to skip this layer at this point 908 // because we cannot call updateTeximage() without a corresponding 909 // compositionComplete() call. 910 // we'll trigger an update in onPreComposition(). 911 if (mRefreshPending) { 912 return outDirtyRegion; 913 } 914 915 // Capture the old state of the layer for comparisons later 916 const bool oldOpacity = isOpaque(); 917 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 918 919 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 920 Layer::State& front; 921 Layer::State& current; 922 bool& recomputeVisibleRegions; 923 Reject(Layer::State& front, Layer::State& current, 924 bool& recomputeVisibleRegions) 925 : front(front), current(current), 926 recomputeVisibleRegions(recomputeVisibleRegions) { 927 } 928 929 virtual bool reject(const sp<GraphicBuffer>& buf, 930 const BufferQueue::BufferItem& item) { 931 if (buf == NULL) { 932 return false; 933 } 934 935 uint32_t bufWidth = buf->getWidth(); 936 uint32_t bufHeight = buf->getHeight(); 937 938 // check that we received a buffer of the right size 939 // (Take the buffer's orientation into account) 940 if (item.mTransform & Transform::ROT_90) { 941 swap(bufWidth, bufHeight); 942 } 943 944 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 945 if (front.active != front.requested) { 946 947 if (isFixedSize || 948 (bufWidth == front.requested.w && 949 bufHeight == front.requested.h)) 950 { 951 // Here we pretend the transaction happened by updating the 952 // current and drawing states. Drawing state is only accessed 953 // in this thread, no need to have it locked 954 front.active = front.requested; 955 956 // We also need to update the current state so that 957 // we don't end-up overwriting the drawing state with 958 // this stale current state during the next transaction 959 // 960 // NOTE: We don't need to hold the transaction lock here 961 // because State::active is only accessed from this thread. 962 current.active = front.active; 963 964 // recompute visible region 965 recomputeVisibleRegions = true; 966 } 967 968 ALOGD_IF(DEBUG_RESIZE, 969 "latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 970 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 971 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 972 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 973 front.active.w, front.active.h, 974 front.active.crop.left, 975 front.active.crop.top, 976 front.active.crop.right, 977 front.active.crop.bottom, 978 front.active.crop.getWidth(), 979 front.active.crop.getHeight(), 980 front.requested.w, front.requested.h, 981 front.requested.crop.left, 982 front.requested.crop.top, 983 front.requested.crop.right, 984 front.requested.crop.bottom, 985 front.requested.crop.getWidth(), 986 front.requested.crop.getHeight()); 987 } 988 989 if (!isFixedSize) { 990 if (front.active.w != bufWidth || 991 front.active.h != bufHeight) { 992 // reject this buffer 993 return true; 994 } 995 } 996 997 // if the transparent region has changed (this test is 998 // conservative, but that's fine, worst case we're doing 999 // a bit of extra work), we latch the new one and we 1000 // trigger a visible-region recompute. 1001 if (!front.activeTransparentRegion.isTriviallyEqual( 1002 front.requestedTransparentRegion)) { 1003 front.activeTransparentRegion = front.requestedTransparentRegion; 1004 1005 // We also need to update the current state so that 1006 // we don't end-up overwriting the drawing state with 1007 // this stale current state during the next transaction 1008 // 1009 // NOTE: We don't need to hold the transaction lock here 1010 // because State::active is only accessed from this thread. 1011 current.activeTransparentRegion = front.activeTransparentRegion; 1012 1013 // recompute visible region 1014 recomputeVisibleRegions = true; 1015 } 1016 1017 return false; 1018 } 1019 }; 1020 1021 1022 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions); 1023 1024 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r); 1025 if (updateResult == BufferQueue::PRESENT_LATER) { 1026 // Producer doesn't want buffer to be displayed yet. Signal a 1027 // layer update so we check again at the next opportunity. 1028 mFlinger->signalLayerUpdate(); 1029 return outDirtyRegion; 1030 } 1031 1032 // Decrement the queued-frames count. Signal another event if we 1033 // have more frames pending. 1034 if (android_atomic_dec(&mQueuedFrames) > 1) { 1035 mFlinger->signalLayerUpdate(); 1036 } 1037 1038 if (updateResult != NO_ERROR) { 1039 // something happened! 1040 recomputeVisibleRegions = true; 1041 return outDirtyRegion; 1042 } 1043 1044 // update the active buffer 1045 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 1046 if (mActiveBuffer == NULL) { 1047 // this can only happen if the very first buffer was rejected. 1048 return outDirtyRegion; 1049 } 1050 1051 mRefreshPending = true; 1052 mFrameLatencyNeeded = true; 1053 if (oldActiveBuffer == NULL) { 1054 // the first time we receive a buffer, we need to trigger a 1055 // geometry invalidation. 1056 recomputeVisibleRegions = true; 1057 } 1058 1059 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 1060 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 1061 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 1062 if ((crop != mCurrentCrop) || 1063 (transform != mCurrentTransform) || 1064 (scalingMode != mCurrentScalingMode)) 1065 { 1066 mCurrentCrop = crop; 1067 mCurrentTransform = transform; 1068 mCurrentScalingMode = scalingMode; 1069 recomputeVisibleRegions = true; 1070 } 1071 1072 if (oldActiveBuffer != NULL) { 1073 uint32_t bufWidth = mActiveBuffer->getWidth(); 1074 uint32_t bufHeight = mActiveBuffer->getHeight(); 1075 if (bufWidth != uint32_t(oldActiveBuffer->width) || 1076 bufHeight != uint32_t(oldActiveBuffer->height)) { 1077 recomputeVisibleRegions = true; 1078 } 1079 } 1080 1081 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 1082 if (oldOpacity != isOpaque()) { 1083 recomputeVisibleRegions = true; 1084 } 1085 1086 // FIXME: postedRegion should be dirty & bounds 1087 const Layer::State& s(getDrawingState()); 1088 Region dirtyRegion(Rect(s.active.w, s.active.h)); 1089 1090 // transform the dirty region to window-manager space 1091 outDirtyRegion = (s.transform.transform(dirtyRegion)); 1092 } 1093 return outDirtyRegion; 1094} 1095 1096uint32_t Layer::getEffectiveUsage(uint32_t usage) const 1097{ 1098 // TODO: should we do something special if mSecure is set? 1099 if (mProtectedByApp) { 1100 // need a hardware-protected path to external video sink 1101 usage |= GraphicBuffer::USAGE_PROTECTED; 1102 } 1103 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 1104 return usage; 1105} 1106 1107void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 1108 uint32_t orientation = 0; 1109 if (!mFlinger->mDebugDisableTransformHint) { 1110 // The transform hint is used to improve performance, but we can 1111 // only have a single transform hint, it cannot 1112 // apply to all displays. 1113 const Transform& planeTransform(hw->getTransform()); 1114 orientation = planeTransform.getOrientation(); 1115 if (orientation & Transform::ROT_INVALID) { 1116 orientation = 0; 1117 } 1118 } 1119 mSurfaceFlingerConsumer->setTransformHint(orientation); 1120} 1121 1122// ---------------------------------------------------------------------------- 1123// debugging 1124// ---------------------------------------------------------------------------- 1125 1126void Layer::dump(String8& result, Colorizer& colorizer) const 1127{ 1128 const Layer::State& s(getDrawingState()); 1129 1130 colorizer.colorize(result, Colorizer::GREEN); 1131 result.appendFormat( 1132 "+ %s %p (%s)\n", 1133 getTypeId(), this, getName().string()); 1134 colorizer.reset(result); 1135 1136 s.activeTransparentRegion.dump(result, "transparentRegion"); 1137 visibleRegion.dump(result, "visibleRegion"); 1138 sp<Client> client(mClientRef.promote()); 1139 1140 result.appendFormat( " " 1141 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), " 1142 "isOpaque=%1d, invalidate=%1d, " 1143 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 1144 " client=%p\n", 1145 s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h, 1146 s.active.crop.left, s.active.crop.top, 1147 s.active.crop.right, s.active.crop.bottom, 1148 isOpaque(), contentDirty, 1149 s.alpha, s.flags, 1150 s.transform[0][0], s.transform[0][1], 1151 s.transform[1][0], s.transform[1][1], 1152 client.get()); 1153 1154 sp<const GraphicBuffer> buf0(mActiveBuffer); 1155 uint32_t w0=0, h0=0, s0=0, f0=0; 1156 if (buf0 != 0) { 1157 w0 = buf0->getWidth(); 1158 h0 = buf0->getHeight(); 1159 s0 = buf0->getStride(); 1160 f0 = buf0->format; 1161 } 1162 result.appendFormat( 1163 " " 1164 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 1165 " queued-frames=%d, mRefreshPending=%d\n", 1166 mFormat, w0, h0, s0,f0, 1167 mQueuedFrames, mRefreshPending); 1168 1169 if (mSurfaceFlingerConsumer != 0) { 1170 mSurfaceFlingerConsumer->dump(result, " "); 1171 } 1172} 1173 1174void Layer::dumpStats(String8& result) const { 1175 mFrameTracker.dump(result); 1176} 1177 1178void Layer::clearStats() { 1179 mFrameTracker.clear(); 1180} 1181 1182// --------------------------------------------------------------------------- 1183 1184Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 1185 const sp<Layer>& layer) 1186 : mFlinger(flinger), mLayer(layer) { 1187} 1188 1189Layer::LayerCleaner::~LayerCleaner() { 1190 // destroy client resources 1191 mFlinger->onLayerDestroyed(mLayer); 1192} 1193 1194// --------------------------------------------------------------------------- 1195 1196 1197}; // namespace android 1198