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