Layer.cpp revision db89edc94bd2a78226b407f9f7261e202e7fa325
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 nsecs_t displayPeriod = 109 flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 110 mFrameTracker.setDisplayRefreshPeriod(displayPeriod); 111} 112 113void Layer::onFirstRef() 114{ 115 // Creates a custom BufferQueue for SurfaceFlingerConsumer to use 116 mBufferQueue = new SurfaceTextureLayer(mFlinger); 117 mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(mBufferQueue, mTextureName, 118 GL_TEXTURE_EXTERNAL_OES, false); 119 120 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 121 mSurfaceFlingerConsumer->setFrameAvailableListener(this); 122 mSurfaceFlingerConsumer->setName(mName); 123 124#ifdef TARGET_DISABLE_TRIPLE_BUFFERING 125#warning "disabling triple buffering" 126 mSurfaceFlingerConsumer->setDefaultMaxBufferCount(2); 127#else 128 mSurfaceFlingerConsumer->setDefaultMaxBufferCount(3); 129#endif 130 131 const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); 132 updateTransformHint(hw); 133} 134 135Layer::~Layer() { 136 sp<Client> c(mClientRef.promote()); 137 if (c != 0) { 138 c->detachLayer(this); 139 } 140 mFlinger->deleteTextureAsync(mTextureName); 141 mFrameTracker.logAndResetStats(mName); 142} 143 144// --------------------------------------------------------------------------- 145// callbacks 146// --------------------------------------------------------------------------- 147 148void Layer::onLayerDisplayed(const sp<const DisplayDevice>& hw, 149 HWComposer::HWCLayerInterface* layer) { 150 if (layer) { 151 layer->onDisplayed(); 152 mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFence()); 153 } 154} 155 156void Layer::onFrameAvailable() { 157 android_atomic_inc(&mQueuedFrames); 158 mFlinger->signalLayerUpdate(); 159} 160 161// called with SurfaceFlinger::mStateLock from the drawing thread after 162// the layer has been remove from the current state list (and just before 163// it's removed from the drawing state list) 164void Layer::onRemoved() { 165 mSurfaceFlingerConsumer->abandon(); 166} 167 168// --------------------------------------------------------------------------- 169// set-up 170// --------------------------------------------------------------------------- 171 172const String8& Layer::getName() const { 173 return mName; 174} 175 176status_t Layer::setBuffers( uint32_t w, uint32_t h, 177 PixelFormat format, uint32_t flags) 178{ 179 uint32_t const maxSurfaceDims = min( 180 mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); 181 182 // never allow a surface larger than what our underlying GL implementation 183 // can handle. 184 if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) { 185 ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); 186 return BAD_VALUE; 187 } 188 189 mFormat = format; 190 191 mSecure = (flags & ISurfaceComposerClient::eSecure) ? true : false; 192 mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; 193 mOpaqueLayer = (flags & ISurfaceComposerClient::eOpaque); 194 mCurrentOpacity = getOpacityForFormat(format); 195 196 mSurfaceFlingerConsumer->setDefaultBufferSize(w, h); 197 mSurfaceFlingerConsumer->setDefaultBufferFormat(format); 198 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 199 200 return NO_ERROR; 201} 202 203sp<IBinder> Layer::getHandle() { 204 Mutex::Autolock _l(mLock); 205 206 LOG_ALWAYS_FATAL_IF(mHasSurface, 207 "Layer::getHandle() has already been called"); 208 209 mHasSurface = true; 210 211 /* 212 * The layer handle is just a BBinder object passed to the client 213 * (remote process) -- we don't keep any reference on our side such that 214 * the dtor is called when the remote side let go of its reference. 215 * 216 * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for 217 * this layer when the handle is destroyed. 218 */ 219 220 class Handle : public BBinder, public LayerCleaner { 221 wp<const Layer> mOwner; 222 public: 223 Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer) 224 : LayerCleaner(flinger, layer), mOwner(layer) { 225 } 226 }; 227 228 return new Handle(mFlinger, this); 229} 230 231sp<IGraphicBufferProducer> Layer::getBufferQueue() const { 232 return mBufferQueue; 233} 234 235// --------------------------------------------------------------------------- 236// h/w composer set-up 237// --------------------------------------------------------------------------- 238 239Rect Layer::getContentCrop() const { 240 // this is the crop rectangle that applies to the buffer 241 // itself (as opposed to the window) 242 Rect crop; 243 if (!mCurrentCrop.isEmpty()) { 244 // if the buffer crop is defined, we use that 245 crop = mCurrentCrop; 246 } else if (mActiveBuffer != NULL) { 247 // otherwise we use the whole buffer 248 crop = mActiveBuffer->getBounds(); 249 } else { 250 // if we don't have a buffer yet, we use an empty/invalid crop 251 crop.makeInvalid(); 252 } 253 return crop; 254} 255 256static Rect reduce(const Rect& win, const Region& exclude) { 257 if (CC_LIKELY(exclude.isEmpty())) { 258 return win; 259 } 260 if (exclude.isRect()) { 261 return win.reduce(exclude.getBounds()); 262 } 263 return Region(win).subtract(exclude).getBounds(); 264} 265 266Rect Layer::computeBounds() const { 267 const Layer::State& s(getDrawingState()); 268 Rect win(s.active.w, s.active.h); 269 if (!s.active.crop.isEmpty()) { 270 win.intersect(s.active.crop, &win); 271 } 272 // subtract the transparent region and snap to the bounds 273 return reduce(win, s.activeTransparentRegion); 274} 275 276FloatRect Layer::computeCrop(const sp<const DisplayDevice>& hw) const { 277 // the content crop is the area of the content that gets scaled to the 278 // layer's size. 279 FloatRect crop(getContentCrop()); 280 281 // the active.crop is the area of the window that gets cropped, but not 282 // scaled in any ways. 283 const State& s(getDrawingState()); 284 285 // apply the projection's clipping to the window crop in 286 // layerstack space, and convert-back to layer space. 287 // if there are no window scaling involved, this operation will map to full 288 // pixels in the buffer. 289 // FIXME: the 3 lines below can produce slightly incorrect clipping when we have 290 // a viewport clipping and a window transform. we should use floating point to fix this. 291 Rect activeCrop(s.transform.transform(s.active.crop)); 292 activeCrop.intersect(hw->getViewport(), &activeCrop); 293 activeCrop = s.transform.inverse().transform(activeCrop); 294 295 // paranoia: make sure the window-crop is constrained in the 296 // window's bounds 297 activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop); 298 299 // subtract the transparent region and snap to the bounds 300 activeCrop = reduce(activeCrop, s.activeTransparentRegion); 301 302 if (!activeCrop.isEmpty()) { 303 // Transform the window crop to match the buffer coordinate system, 304 // which means using the inverse of the current transform set on the 305 // SurfaceFlingerConsumer. 306 uint32_t invTransform = mCurrentTransform; 307 int winWidth = s.active.w; 308 int winHeight = s.active.h; 309 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 310 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 311 NATIVE_WINDOW_TRANSFORM_FLIP_H; 312 winWidth = s.active.h; 313 winHeight = s.active.w; 314 } 315 const Rect winCrop = activeCrop.transform( 316 invTransform, s.active.w, s.active.h); 317 318 // below, crop is intersected with winCrop expressed in crop's coordinate space 319 float xScale = crop.getWidth() / float(winWidth); 320 float yScale = crop.getHeight() / float(winHeight); 321 322 float insetL = winCrop.left * xScale; 323 float insetT = winCrop.top * yScale; 324 float insetR = (winWidth - winCrop.right ) * xScale; 325 float insetB = (winHeight - winCrop.bottom) * yScale; 326 327 crop.left += insetL; 328 crop.top += insetT; 329 crop.right -= insetR; 330 crop.bottom -= insetB; 331 } 332 return crop; 333} 334 335void Layer::setGeometry( 336 const sp<const DisplayDevice>& hw, 337 HWComposer::HWCLayerInterface& layer) 338{ 339 layer.setDefaultState(); 340 341 // enable this layer 342 layer.setSkip(false); 343 344 if (isSecure() && !hw->isSecure()) { 345 layer.setSkip(true); 346 } 347 348 // this gives us only the "orientation" component of the transform 349 const State& s(getDrawingState()); 350 if (!isOpaque() || s.alpha != 0xFF) { 351 layer.setBlending(mPremultipliedAlpha ? 352 HWC_BLENDING_PREMULT : 353 HWC_BLENDING_COVERAGE); 354 } 355 356 // apply the layer's transform, followed by the display's global transform 357 // here we're guaranteed that the layer's transform preserves rects 358 Rect frame(s.transform.transform(computeBounds())); 359 frame.intersect(hw->getViewport(), &frame); 360 const Transform& tr(hw->getTransform()); 361 layer.setFrame(tr.transform(frame)); 362 layer.setCrop(computeCrop(hw)); 363 layer.setPlaneAlpha(s.alpha); 364 365 /* 366 * Transformations are applied in this order: 367 * 1) buffer orientation/flip/mirror 368 * 2) state transformation (window manager) 369 * 3) layer orientation (screen orientation) 370 * (NOTE: the matrices are multiplied in reverse order) 371 */ 372 373 const Transform bufferOrientation(mCurrentTransform); 374 const Transform transform(tr * s.transform * bufferOrientation); 375 376 // this gives us only the "orientation" component of the transform 377 const uint32_t orientation = transform.getOrientation(); 378 if (orientation & Transform::ROT_INVALID) { 379 // we can only handle simple transformation 380 layer.setSkip(true); 381 } else { 382 layer.setTransform(orientation); 383 } 384} 385 386void Layer::setPerFrameData(const sp<const DisplayDevice>& hw, 387 HWComposer::HWCLayerInterface& layer) { 388 // we have to set the visible region on every frame because 389 // we currently free it during onLayerDisplayed(), which is called 390 // after HWComposer::commit() -- every frame. 391 // Apply this display's projection's viewport to the visible region 392 // before giving it to the HWC HAL. 393 const Transform& tr = hw->getTransform(); 394 Region visible = tr.transform(visibleRegion.intersect(hw->getViewport())); 395 layer.setVisibleRegionScreen(visible); 396 397 // NOTE: buffer can be NULL if the client never drew into this 398 // layer yet, or if we ran out of memory 399 layer.setBuffer(mActiveBuffer); 400} 401 402void Layer::setAcquireFence(const sp<const DisplayDevice>& hw, 403 HWComposer::HWCLayerInterface& layer) { 404 int fenceFd = -1; 405 406 // TODO: there is a possible optimization here: we only need to set the 407 // acquire fence the first time a new buffer is acquired on EACH display. 408 409 if (layer.getCompositionType() == HWC_OVERLAY) { 410 sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence(); 411 if (fence->isValid()) { 412 fenceFd = fence->dup(); 413 if (fenceFd == -1) { 414 ALOGW("failed to dup layer fence, skipping sync: %d", errno); 415 } 416 } 417 } 418 layer.setAcquireFenceFd(fenceFd); 419} 420 421// --------------------------------------------------------------------------- 422// drawing... 423// --------------------------------------------------------------------------- 424 425void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const { 426 onDraw(hw, clip); 427} 428 429void Layer::draw(const sp<const DisplayDevice>& hw) { 430 onDraw( hw, Region(hw->bounds()) ); 431} 432 433void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip) const 434{ 435 ATRACE_CALL(); 436 437 if (CC_UNLIKELY(mActiveBuffer == 0)) { 438 // the texture has not been created yet, this Layer has 439 // in fact never been drawn into. This happens frequently with 440 // SurfaceView because the WindowManager can't know when the client 441 // has drawn the first time. 442 443 // If there is nothing under us, we paint the screen in black, otherwise 444 // we just skip this update. 445 446 // figure out if there is something below us 447 Region under; 448 const SurfaceFlinger::LayerVector& drawingLayers( 449 mFlinger->mDrawingState.layersSortedByZ); 450 const size_t count = drawingLayers.size(); 451 for (size_t i=0 ; i<count ; ++i) { 452 const sp<Layer>& layer(drawingLayers[i]); 453 if (layer.get() == static_cast<Layer const*>(this)) 454 break; 455 under.orSelf( hw->getTransform().transform(layer->visibleRegion) ); 456 } 457 // if not everything below us is covered, we plug the holes! 458 Region holes(clip.subtract(under)); 459 if (!holes.isEmpty()) { 460 clearWithOpenGL(hw, holes, 0, 0, 0, 1); 461 } 462 return; 463 } 464 465 // Bind the current buffer to the GL texture, and wait for it to be 466 // ready for us to draw into. 467 status_t err = mSurfaceFlingerConsumer->bindTextureImage(); 468 if (err != NO_ERROR) { 469 ALOGW("onDraw: bindTextureImage failed (err=%d)", err); 470 // Go ahead and draw the buffer anyway; no matter what we do the screen 471 // is probably going to have something visibly wrong. 472 } 473 474 bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure()); 475 476 RenderEngine& engine(mFlinger->getRenderEngine()); 477 478 if (!blackOutLayer) { 479 // TODO: we could be more subtle with isFixedSize() 480 const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize(); 481 482 // Query the texture matrix given our current filtering mode. 483 float textureMatrix[16]; 484 mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering); 485 mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix); 486 487 // Set things up for texturing. 488 engine.setupLayerTexturing(mTextureName, useFiltering, textureMatrix); 489 } else { 490 engine.setupLayerBlackedOut(); 491 } 492 drawWithOpenGL(hw, clip); 493 engine.disableTexturing(); 494} 495 496 497void Layer::clearWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip, 498 GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) const 499{ 500 LayerMesh mesh; 501 computeGeometry(hw, &mesh); 502 503 mFlinger->getRenderEngine().clearWithColor( 504 mesh.getVertices(), mesh.getVertexCount(), 505 red, green, blue, alpha); 506} 507 508void Layer::clearWithOpenGL( 509 const sp<const DisplayDevice>& hw, const Region& clip) const { 510 clearWithOpenGL(hw, clip, 0,0,0,0); 511} 512 513void Layer::drawWithOpenGL( 514 const sp<const DisplayDevice>& hw, const Region& clip) const { 515 const uint32_t fbHeight = hw->getHeight(); 516 const State& s(getDrawingState()); 517 518 LayerMesh mesh; 519 computeGeometry(hw, &mesh); 520 521 /* 522 * NOTE: the way we compute the texture coordinates here produces 523 * different results than when we take the HWC path -- in the later case 524 * the "source crop" is rounded to texel boundaries. 525 * This can produce significantly different results when the texture 526 * is scaled by a large amount. 527 * 528 * The GL code below is more logical (imho), and the difference with 529 * HWC is due to a limitation of the HWC API to integers -- a question 530 * is suspend is wether we should ignore this problem or revert to 531 * GL composition when a buffer scaling is applied (maybe with some 532 * minimal value)? Or, we could make GL behave like HWC -- but this feel 533 * like more of a hack. 534 */ 535 const Rect win(computeBounds()); 536 537 GLfloat left = GLfloat(win.left) / GLfloat(s.active.w); 538 GLfloat top = GLfloat(win.top) / GLfloat(s.active.h); 539 GLfloat right = GLfloat(win.right) / GLfloat(s.active.w); 540 GLfloat bottom = GLfloat(win.bottom) / GLfloat(s.active.h); 541 542 // TODO: we probably want to generate the texture coords with the mesh 543 // here we assume that we only have 4 vertices 544 float texCoords[4][2]; 545 texCoords[0][0] = left; 546 texCoords[0][1] = top; 547 texCoords[1][0] = left; 548 texCoords[1][1] = bottom; 549 texCoords[2][0] = right; 550 texCoords[2][1] = bottom; 551 texCoords[3][0] = right; 552 texCoords[3][1] = top; 553 for (int i = 0; i < 4; i++) { 554 texCoords[i][1] = 1.0f - texCoords[i][1]; 555 } 556 557 RenderEngine& engine(mFlinger->getRenderEngine()); 558 engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(), s.alpha); 559 engine.drawMesh2D(mesh.getVertices(), texCoords, mesh.getVertexCount()); 560 engine.disableBlending(); 561} 562 563void Layer::setFiltering(bool filtering) { 564 mFiltering = filtering; 565} 566 567bool Layer::getFiltering() const { 568 return mFiltering; 569} 570 571// As documented in libhardware header, formats in the range 572// 0x100 - 0x1FF are specific to the HAL implementation, and 573// are known to have no alpha channel 574// TODO: move definition for device-specific range into 575// hardware.h, instead of using hard-coded values here. 576#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) 577 578bool Layer::getOpacityForFormat(uint32_t format) { 579 if (HARDWARE_IS_DEVICE_FORMAT(format)) { 580 return true; 581 } 582 switch (format) { 583 case HAL_PIXEL_FORMAT_RGBA_8888: 584 case HAL_PIXEL_FORMAT_BGRA_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, LayerMesh* 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 if (mesh) { 607 tr.transform(mesh->mVertices[0], win.left, win.top); 608 tr.transform(mesh->mVertices[1], win.left, win.bottom); 609 tr.transform(mesh->mVertices[2], win.right, win.bottom); 610 tr.transform(mesh->mVertices[3], win.right, win.top); 611 for (size_t i=0 ; i<4 ; i++) { 612 mesh->mVertices[i][1] = hw_h - mesh->mVertices[i][1]; 613 } 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 return true; 993 } 994 } 995 996 // if the transparent region has changed (this test is 997 // conservative, but that's fine, worst case we're doing 998 // a bit of extra work), we latch the new one and we 999 // trigger a visible-region recompute. 1000 if (!front.activeTransparentRegion.isTriviallyEqual( 1001 front.requestedTransparentRegion)) { 1002 front.activeTransparentRegion = front.requestedTransparentRegion; 1003 1004 // We also need to update the current state so that 1005 // we don't end-up overwriting the drawing state with 1006 // this stale current state during the next transaction 1007 // 1008 // NOTE: We don't need to hold the transaction lock here 1009 // because State::active is only accessed from this thread. 1010 current.activeTransparentRegion = front.activeTransparentRegion; 1011 1012 // recompute visible region 1013 recomputeVisibleRegions = true; 1014 } 1015 1016 return false; 1017 } 1018 }; 1019 1020 1021 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions); 1022 1023 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r); 1024 if (updateResult == BufferQueue::PRESENT_LATER) { 1025 // Producer doesn't want buffer to be displayed yet. Signal a 1026 // layer update so we check again at the next opportunity. 1027 mFlinger->signalLayerUpdate(); 1028 return outDirtyRegion; 1029 } 1030 1031 // Decrement the queued-frames count. Signal another event if we 1032 // have more frames pending. 1033 if (android_atomic_dec(&mQueuedFrames) > 1) { 1034 mFlinger->signalLayerUpdate(); 1035 } 1036 1037 if (updateResult != NO_ERROR) { 1038 // something happened! 1039 recomputeVisibleRegions = true; 1040 return outDirtyRegion; 1041 } 1042 1043 // update the active buffer 1044 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 1045 if (mActiveBuffer == NULL) { 1046 // this can only happen if the very first buffer was rejected. 1047 return outDirtyRegion; 1048 } 1049 1050 mRefreshPending = true; 1051 mFrameLatencyNeeded = true; 1052 if (oldActiveBuffer == NULL) { 1053 // the first time we receive a buffer, we need to trigger a 1054 // geometry invalidation. 1055 recomputeVisibleRegions = true; 1056 } 1057 1058 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 1059 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 1060 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 1061 if ((crop != mCurrentCrop) || 1062 (transform != mCurrentTransform) || 1063 (scalingMode != mCurrentScalingMode)) 1064 { 1065 mCurrentCrop = crop; 1066 mCurrentTransform = transform; 1067 mCurrentScalingMode = scalingMode; 1068 recomputeVisibleRegions = true; 1069 } 1070 1071 if (oldActiveBuffer != NULL) { 1072 uint32_t bufWidth = mActiveBuffer->getWidth(); 1073 uint32_t bufHeight = mActiveBuffer->getHeight(); 1074 if (bufWidth != uint32_t(oldActiveBuffer->width) || 1075 bufHeight != uint32_t(oldActiveBuffer->height)) { 1076 recomputeVisibleRegions = true; 1077 } 1078 } 1079 1080 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 1081 if (oldOpacity != isOpaque()) { 1082 recomputeVisibleRegions = true; 1083 } 1084 1085 // FIXME: postedRegion should be dirty & bounds 1086 const Layer::State& s(getDrawingState()); 1087 Region dirtyRegion(Rect(s.active.w, s.active.h)); 1088 1089 // transform the dirty region to window-manager space 1090 outDirtyRegion = (s.transform.transform(dirtyRegion)); 1091 } 1092 return outDirtyRegion; 1093} 1094 1095uint32_t Layer::getEffectiveUsage(uint32_t usage) const 1096{ 1097 // TODO: should we do something special if mSecure is set? 1098 if (mProtectedByApp) { 1099 // need a hardware-protected path to external video sink 1100 usage |= GraphicBuffer::USAGE_PROTECTED; 1101 } 1102 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 1103 return usage; 1104} 1105 1106void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 1107 uint32_t orientation = 0; 1108 if (!mFlinger->mDebugDisableTransformHint) { 1109 // The transform hint is used to improve performance, but we can 1110 // only have a single transform hint, it cannot 1111 // apply to all displays. 1112 const Transform& planeTransform(hw->getTransform()); 1113 orientation = planeTransform.getOrientation(); 1114 if (orientation & Transform::ROT_INVALID) { 1115 orientation = 0; 1116 } 1117 } 1118 mSurfaceFlingerConsumer->setTransformHint(orientation); 1119} 1120 1121// ---------------------------------------------------------------------------- 1122// debugging 1123// ---------------------------------------------------------------------------- 1124 1125void Layer::dump(String8& result, Colorizer& colorizer) const 1126{ 1127 const Layer::State& s(getDrawingState()); 1128 1129 colorizer.colorize(result, Colorizer::GREEN); 1130 result.appendFormat( 1131 "+ %s %p (%s)\n", 1132 getTypeId(), this, getName().string()); 1133 colorizer.reset(result); 1134 1135 s.activeTransparentRegion.dump(result, "transparentRegion"); 1136 visibleRegion.dump(result, "visibleRegion"); 1137 sp<Client> client(mClientRef.promote()); 1138 1139 result.appendFormat( " " 1140 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), " 1141 "isOpaque=%1d, invalidate=%1d, " 1142 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 1143 " client=%p\n", 1144 s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h, 1145 s.active.crop.left, s.active.crop.top, 1146 s.active.crop.right, s.active.crop.bottom, 1147 isOpaque(), contentDirty, 1148 s.alpha, s.flags, 1149 s.transform[0][0], s.transform[0][1], 1150 s.transform[1][0], s.transform[1][1], 1151 client.get()); 1152 1153 sp<const GraphicBuffer> buf0(mActiveBuffer); 1154 uint32_t w0=0, h0=0, s0=0, f0=0; 1155 if (buf0 != 0) { 1156 w0 = buf0->getWidth(); 1157 h0 = buf0->getHeight(); 1158 s0 = buf0->getStride(); 1159 f0 = buf0->format; 1160 } 1161 result.appendFormat( 1162 " " 1163 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 1164 " queued-frames=%d, mRefreshPending=%d\n", 1165 mFormat, w0, h0, s0,f0, 1166 mQueuedFrames, mRefreshPending); 1167 1168 if (mSurfaceFlingerConsumer != 0) { 1169 mSurfaceFlingerConsumer->dump(result, " "); 1170 } 1171} 1172 1173void Layer::dumpStats(String8& result) const { 1174 mFrameTracker.dump(result); 1175} 1176 1177void Layer::clearStats() { 1178 mFrameTracker.clear(); 1179} 1180 1181void Layer::logFrameStats() { 1182 mFrameTracker.logAndResetStats(mName); 1183} 1184 1185// --------------------------------------------------------------------------- 1186 1187Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 1188 const sp<Layer>& layer) 1189 : mFlinger(flinger), mLayer(layer) { 1190} 1191 1192Layer::LayerCleaner::~LayerCleaner() { 1193 // destroy client resources 1194 mFlinger->onLayerDestroyed(mLayer); 1195} 1196 1197// --------------------------------------------------------------------------- 1198 1199 1200}; // namespace android 1201