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