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