Layer.cpp revision 3f84483382be2d528918cc1a6fbc6a7d68e0b181
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 mFlinger->getRenderEngine().genTextures(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 // Creates a custom BufferQueue for SurfaceFlingerConsumer to use 115 mBufferQueue = new SurfaceTextureLayer(mFlinger); 116 mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(mBufferQueue, mTextureName); 117 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 118 mSurfaceFlingerConsumer->setFrameAvailableListener(this); 119 mSurfaceFlingerConsumer->setName(mName); 120 121#ifdef TARGET_DISABLE_TRIPLE_BUFFERING 122#warning "disabling triple buffering" 123 mSurfaceFlingerConsumer->setDefaultMaxBufferCount(2); 124#else 125 mSurfaceFlingerConsumer->setDefaultMaxBufferCount(3); 126#endif 127 128 const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); 129 updateTransformHint(hw); 130} 131 132Layer::~Layer() { 133 sp<Client> c(mClientRef.promote()); 134 if (c != 0) { 135 c->detachLayer(this); 136 } 137 mFlinger->deleteTextureAsync(mTextureName); 138 mFrameTracker.logAndResetStats(mName); 139} 140 141// --------------------------------------------------------------------------- 142// callbacks 143// --------------------------------------------------------------------------- 144 145void Layer::onLayerDisplayed(const sp<const DisplayDevice>& hw, 146 HWComposer::HWCLayerInterface* layer) { 147 if (layer) { 148 layer->onDisplayed(); 149 mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFence()); 150 } 151} 152 153void Layer::onFrameAvailable() { 154 android_atomic_inc(&mQueuedFrames); 155 mFlinger->signalLayerUpdate(); 156} 157 158// called with SurfaceFlinger::mStateLock from the drawing thread after 159// the layer has been remove from the current state list (and just before 160// it's removed from the drawing state list) 161void Layer::onRemoved() { 162 mSurfaceFlingerConsumer->abandon(); 163} 164 165// --------------------------------------------------------------------------- 166// set-up 167// --------------------------------------------------------------------------- 168 169const String8& Layer::getName() const { 170 return mName; 171} 172 173status_t Layer::setBuffers( uint32_t w, uint32_t h, 174 PixelFormat format, uint32_t flags) 175{ 176 uint32_t const maxSurfaceDims = min( 177 mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); 178 179 // never allow a surface larger than what our underlying GL implementation 180 // can handle. 181 if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) { 182 ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); 183 return BAD_VALUE; 184 } 185 186 mFormat = format; 187 188 mSecure = (flags & ISurfaceComposerClient::eSecure) ? true : false; 189 mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; 190 mOpaqueLayer = (flags & ISurfaceComposerClient::eOpaque); 191 mCurrentOpacity = getOpacityForFormat(format); 192 193 mSurfaceFlingerConsumer->setDefaultBufferSize(w, h); 194 mSurfaceFlingerConsumer->setDefaultBufferFormat(format); 195 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 196 197 return NO_ERROR; 198} 199 200sp<IBinder> Layer::getHandle() { 201 Mutex::Autolock _l(mLock); 202 203 LOG_ALWAYS_FATAL_IF(mHasSurface, 204 "Layer::getHandle() has already been called"); 205 206 mHasSurface = true; 207 208 /* 209 * The layer handle is just a BBinder object passed to the client 210 * (remote process) -- we don't keep any reference on our side such that 211 * the dtor is called when the remote side let go of its reference. 212 * 213 * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for 214 * this layer when the handle is destroyed. 215 */ 216 217 class Handle : public BBinder, public LayerCleaner { 218 wp<const Layer> mOwner; 219 public: 220 Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer) 221 : LayerCleaner(flinger, layer), mOwner(layer) { 222 } 223 }; 224 225 return new Handle(mFlinger, this); 226} 227 228sp<IGraphicBufferProducer> Layer::getBufferQueue() const { 229 return mBufferQueue; 230} 231 232// --------------------------------------------------------------------------- 233// h/w composer set-up 234// --------------------------------------------------------------------------- 235 236Rect Layer::getContentCrop() const { 237 // this is the crop rectangle that applies to the buffer 238 // itself (as opposed to the window) 239 Rect crop; 240 if (!mCurrentCrop.isEmpty()) { 241 // if the buffer crop is defined, we use that 242 crop = mCurrentCrop; 243 } else if (mActiveBuffer != NULL) { 244 // otherwise we use the whole buffer 245 crop = mActiveBuffer->getBounds(); 246 } else { 247 // if we don't have a buffer yet, we use an empty/invalid crop 248 crop.makeInvalid(); 249 } 250 return crop; 251} 252 253static Rect reduce(const Rect& win, const Region& exclude) { 254 if (CC_LIKELY(exclude.isEmpty())) { 255 return win; 256 } 257 if (exclude.isRect()) { 258 return win.reduce(exclude.getBounds()); 259 } 260 return Region(win).subtract(exclude).getBounds(); 261} 262 263Rect Layer::computeBounds() const { 264 const Layer::State& s(getDrawingState()); 265 Rect win(s.active.w, s.active.h); 266 if (!s.active.crop.isEmpty()) { 267 win.intersect(s.active.crop, &win); 268 } 269 // subtract the transparent region and snap to the bounds 270 return reduce(win, s.activeTransparentRegion); 271} 272 273FloatRect Layer::computeCrop(const sp<const DisplayDevice>& hw) const { 274 // the content crop is the area of the content that gets scaled to the 275 // layer's size. 276 FloatRect crop(getContentCrop()); 277 278 // the active.crop is the area of the window that gets cropped, but not 279 // scaled in any ways. 280 const State& s(getDrawingState()); 281 282 // apply the projection's clipping to the window crop in 283 // layerstack space, and convert-back to layer space. 284 // if there are no window scaling involved, this operation will map to full 285 // pixels in the buffer. 286 // FIXME: the 3 lines below can produce slightly incorrect clipping when we have 287 // a viewport clipping and a window transform. we should use floating point to fix this. 288 Rect activeCrop(s.transform.transform(s.active.crop)); 289 activeCrop.intersect(hw->getViewport(), &activeCrop); 290 activeCrop = s.transform.inverse().transform(activeCrop); 291 292 // paranoia: make sure the window-crop is constrained in the 293 // window's bounds 294 activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop); 295 296 // subtract the transparent region and snap to the bounds 297 activeCrop = reduce(activeCrop, s.activeTransparentRegion); 298 299 if (!activeCrop.isEmpty()) { 300 // Transform the window crop to match the buffer coordinate system, 301 // which means using the inverse of the current transform set on the 302 // SurfaceFlingerConsumer. 303 uint32_t invTransform = mCurrentTransform; 304 int winWidth = s.active.w; 305 int winHeight = s.active.h; 306 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 307 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 308 NATIVE_WINDOW_TRANSFORM_FLIP_H; 309 winWidth = s.active.h; 310 winHeight = s.active.w; 311 } 312 const Rect winCrop = activeCrop.transform( 313 invTransform, s.active.w, s.active.h); 314 315 // below, crop is intersected with winCrop expressed in crop's coordinate space 316 float xScale = crop.getWidth() / float(winWidth); 317 float yScale = crop.getHeight() / float(winHeight); 318 319 float insetL = winCrop.left * xScale; 320 float insetT = winCrop.top * yScale; 321 float insetR = (winWidth - winCrop.right ) * xScale; 322 float insetB = (winHeight - winCrop.bottom) * yScale; 323 324 crop.left += insetL; 325 crop.top += insetT; 326 crop.right -= insetR; 327 crop.bottom -= insetB; 328 } 329 return crop; 330} 331 332void Layer::setGeometry( 333 const sp<const DisplayDevice>& hw, 334 HWComposer::HWCLayerInterface& layer) 335{ 336 layer.setDefaultState(); 337 338 // enable this layer 339 layer.setSkip(false); 340 341 if (isSecure() && !hw->isSecure()) { 342 layer.setSkip(true); 343 } 344 345 // this gives us only the "orientation" component of the transform 346 const State& s(getDrawingState()); 347 if (!isOpaque() || s.alpha != 0xFF) { 348 layer.setBlending(mPremultipliedAlpha ? 349 HWC_BLENDING_PREMULT : 350 HWC_BLENDING_COVERAGE); 351 } 352 353 // apply the layer's transform, followed by the display's global transform 354 // here we're guaranteed that the layer's transform preserves rects 355 Rect frame(s.transform.transform(computeBounds())); 356 frame.intersect(hw->getViewport(), &frame); 357 const Transform& tr(hw->getTransform()); 358 layer.setFrame(tr.transform(frame)); 359 layer.setCrop(computeCrop(hw)); 360 layer.setPlaneAlpha(s.alpha); 361 362 /* 363 * Transformations are applied in this order: 364 * 1) buffer orientation/flip/mirror 365 * 2) state transformation (window manager) 366 * 3) layer orientation (screen orientation) 367 * (NOTE: the matrices are multiplied in reverse order) 368 */ 369 370 const Transform bufferOrientation(mCurrentTransform); 371 const Transform transform(tr * s.transform * bufferOrientation); 372 373 // this gives us only the "orientation" component of the transform 374 const uint32_t orientation = transform.getOrientation(); 375 if (orientation & Transform::ROT_INVALID) { 376 // we can only handle simple transformation 377 layer.setSkip(true); 378 } else { 379 layer.setTransform(orientation); 380 } 381} 382 383void Layer::setPerFrameData(const sp<const DisplayDevice>& hw, 384 HWComposer::HWCLayerInterface& layer) { 385 // we have to set the visible region on every frame because 386 // we currently free it during onLayerDisplayed(), which is called 387 // after HWComposer::commit() -- every frame. 388 // Apply this display's projection's viewport to the visible region 389 // before giving it to the HWC HAL. 390 const Transform& tr = hw->getTransform(); 391 Region visible = tr.transform(visibleRegion.intersect(hw->getViewport())); 392 layer.setVisibleRegionScreen(visible); 393 394 // NOTE: buffer can be NULL if the client never drew into this 395 // layer yet, or if we ran out of memory 396 layer.setBuffer(mActiveBuffer); 397} 398 399void Layer::setAcquireFence(const sp<const DisplayDevice>& hw, 400 HWComposer::HWCLayerInterface& layer) { 401 int fenceFd = -1; 402 403 // TODO: there is a possible optimization here: we only need to set the 404 // acquire fence the first time a new buffer is acquired on EACH display. 405 406 if (layer.getCompositionType() == HWC_OVERLAY) { 407 sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence(); 408 if (fence->isValid()) { 409 fenceFd = fence->dup(); 410 if (fenceFd == -1) { 411 ALOGW("failed to dup layer fence, skipping sync: %d", errno); 412 } 413 } 414 } 415 layer.setAcquireFenceFd(fenceFd); 416} 417 418// --------------------------------------------------------------------------- 419// drawing... 420// --------------------------------------------------------------------------- 421 422void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const { 423 onDraw(hw, clip); 424} 425 426void Layer::draw(const sp<const DisplayDevice>& hw) { 427 onDraw( hw, Region(hw->bounds()) ); 428} 429 430void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip) const 431{ 432 ATRACE_CALL(); 433 434 if (CC_UNLIKELY(mActiveBuffer == 0)) { 435 // the texture has not been created yet, this Layer has 436 // in fact never been drawn into. This happens frequently with 437 // SurfaceView because the WindowManager can't know when the client 438 // has drawn the first time. 439 440 // If there is nothing under us, we paint the screen in black, otherwise 441 // we just skip this update. 442 443 // figure out if there is something below us 444 Region under; 445 const SurfaceFlinger::LayerVector& drawingLayers( 446 mFlinger->mDrawingState.layersSortedByZ); 447 const size_t count = drawingLayers.size(); 448 for (size_t i=0 ; i<count ; ++i) { 449 const sp<Layer>& layer(drawingLayers[i]); 450 if (layer.get() == static_cast<Layer const*>(this)) 451 break; 452 under.orSelf( hw->getTransform().transform(layer->visibleRegion) ); 453 } 454 // if not everything below us is covered, we plug the holes! 455 Region holes(clip.subtract(under)); 456 if (!holes.isEmpty()) { 457 clearWithOpenGL(hw, holes, 0, 0, 0, 1); 458 } 459 return; 460 } 461 462 // Bind the current buffer to the GL texture, and wait for it to be 463 // ready for us to draw into. 464 status_t err = mSurfaceFlingerConsumer->bindTextureImage(); 465 if (err != NO_ERROR) { 466 ALOGW("onDraw: bindTextureImage failed (err=%d)", err); 467 // Go ahead and draw the buffer anyway; no matter what we do the screen 468 // is probably going to have something visibly wrong. 469 } 470 471 bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure()); 472 473 RenderEngine& engine(mFlinger->getRenderEngine()); 474 475 if (!blackOutLayer) { 476 // TODO: we could be more subtle with isFixedSize() 477 const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize(); 478 479 // Query the texture matrix given our current filtering mode. 480 float textureMatrix[16]; 481 mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering); 482 mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix); 483 484 // Set things up for texturing. 485 engine.setupLayerTexturing(mTextureName, useFiltering, textureMatrix); 486 } else { 487 engine.setupLayerBlackedOut(); 488 } 489 drawWithOpenGL(hw, clip); 490 engine.disableTexturing(); 491} 492 493 494void Layer::clearWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip, 495 float red, float green, float blue, float alpha) const 496{ 497 Mesh mesh(Mesh::TRIANGLE_FAN, 4, 2); 498 computeGeometry(hw, mesh); 499 mFlinger->getRenderEngine().fillWithColor(mesh, 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 Mesh mesh(Mesh::TRIANGLE_FAN, 4, 2, 2); 513 computeGeometry(hw, mesh); 514 515 /* 516 * NOTE: the way we compute the texture coordinates here produces 517 * different results than when we take the HWC path -- in the later case 518 * the "source crop" is rounded to texel boundaries. 519 * This can produce significantly different results when the texture 520 * is scaled by a large amount. 521 * 522 * The GL code below is more logical (imho), and the difference with 523 * HWC is due to a limitation of the HWC API to integers -- a question 524 * is suspend is wether we should ignore this problem or revert to 525 * GL composition when a buffer scaling is applied (maybe with some 526 * minimal value)? Or, we could make GL behave like HWC -- but this feel 527 * like more of a hack. 528 */ 529 const Rect win(computeBounds()); 530 531 float left = float(win.left) / float(s.active.w); 532 float top = float(win.top) / float(s.active.h); 533 float right = float(win.right) / float(s.active.w); 534 float bottom = float(win.bottom) / float(s.active.h); 535 536 // TODO: we probably want to generate the texture coords with the mesh 537 // here we assume that we only have 4 vertices 538 size_t stride = mesh.getStride(); 539 float* base = mesh.getTexCoords(); 540 base[stride*0 + 0] = left; 541 base[stride*0 + 1] = 1.0f - top; 542 base[stride*1 + 0] = left; 543 base[stride*1 + 1] = 1.0f - bottom; 544 base[stride*2 + 0] = right; 545 base[stride*2 + 1] = 1.0f - bottom; 546 base[stride*3 + 0] = right; 547 base[stride*3 + 1] = 1.0f - top; 548 549 RenderEngine& engine(mFlinger->getRenderEngine()); 550 engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(), s.alpha); 551 engine.drawMesh(mesh); 552 engine.disableBlending(); 553} 554 555void Layer::setFiltering(bool filtering) { 556 mFiltering = filtering; 557} 558 559bool Layer::getFiltering() const { 560 return mFiltering; 561} 562 563// As documented in libhardware header, formats in the range 564// 0x100 - 0x1FF are specific to the HAL implementation, and 565// are known to have no alpha channel 566// TODO: move definition for device-specific range into 567// hardware.h, instead of using hard-coded values here. 568#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) 569 570bool Layer::getOpacityForFormat(uint32_t format) { 571 if (HARDWARE_IS_DEVICE_FORMAT(format)) { 572 return true; 573 } 574 switch (format) { 575 case HAL_PIXEL_FORMAT_RGBA_8888: 576 case HAL_PIXEL_FORMAT_BGRA_8888: 577 return false; 578 } 579 // in all other case, we have no blending (also for unknown formats) 580 return true; 581} 582 583// ---------------------------------------------------------------------------- 584// local state 585// ---------------------------------------------------------------------------- 586 587void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh) const 588{ 589 const Layer::State& s(getDrawingState()); 590 const Transform tr(hw->getTransform() * s.transform); 591 const uint32_t hw_h = hw->getHeight(); 592 Rect win(s.active.w, s.active.h); 593 if (!s.active.crop.isEmpty()) { 594 win.intersect(s.active.crop, &win); 595 } 596 // subtract the transparent region and snap to the bounds 597 win = reduce(win, s.activeTransparentRegion); 598 599 tr.transform(mesh[0], win.left, win.top); 600 tr.transform(mesh[1], win.left, win.bottom); 601 tr.transform(mesh[2], win.right, win.bottom); 602 tr.transform(mesh[3], win.right, win.top); 603 for (size_t i=0 ; i<4 ; i++) { 604 mesh[i][1] = hw_h - mesh[i][1]; 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