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