Layer.cpp revision 5cdc8994a0ecd751a6350b16a1bef8b6b0d09b11
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 return false; 576 } 577 // in all other case, we have no blending (also for unknown formats) 578 return true; 579} 580 581// ---------------------------------------------------------------------------- 582// local state 583// ---------------------------------------------------------------------------- 584 585void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh) const 586{ 587 const Layer::State& s(getDrawingState()); 588 const Transform tr(hw->getTransform() * s.transform); 589 const uint32_t hw_h = hw->getHeight(); 590 Rect win(s.active.w, s.active.h); 591 if (!s.active.crop.isEmpty()) { 592 win.intersect(s.active.crop, &win); 593 } 594 // subtract the transparent region and snap to the bounds 595 win = reduce(win, s.activeTransparentRegion); 596 597 Mesh::VertexArray position(mesh.getPositionArray()); 598 tr.transform(position[0], win.left, win.top); 599 tr.transform(position[1], win.left, win.bottom); 600 tr.transform(position[2], win.right, win.bottom); 601 tr.transform(position[3], win.right, win.top); 602 for (size_t i=0 ; i<4 ; i++) { 603 position[i].y = hw_h - position[i].y; 604 } 605} 606 607bool Layer::isOpaque() const 608{ 609 // if we don't have a buffer yet, we're translucent regardless of the 610 // layer's opaque flag. 611 if (mActiveBuffer == 0) { 612 return false; 613 } 614 615 // if the layer has the opaque flag, then we're always opaque, 616 // otherwise we use the current buffer's format. 617 return mOpaqueLayer || mCurrentOpacity; 618} 619 620bool Layer::isProtected() const 621{ 622 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 623 return (activeBuffer != 0) && 624 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 625} 626 627bool Layer::isFixedSize() const { 628 return mCurrentScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 629} 630 631bool Layer::isCropped() const { 632 return !mCurrentCrop.isEmpty(); 633} 634 635bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const { 636 return mNeedsFiltering || hw->needsFiltering(); 637} 638 639void Layer::setVisibleRegion(const Region& visibleRegion) { 640 // always called from main thread 641 this->visibleRegion = visibleRegion; 642} 643 644void Layer::setCoveredRegion(const Region& coveredRegion) { 645 // always called from main thread 646 this->coveredRegion = coveredRegion; 647} 648 649void Layer::setVisibleNonTransparentRegion(const Region& 650 setVisibleNonTransparentRegion) { 651 // always called from main thread 652 this->visibleNonTransparentRegion = setVisibleNonTransparentRegion; 653} 654 655// ---------------------------------------------------------------------------- 656// transaction 657// ---------------------------------------------------------------------------- 658 659uint32_t Layer::doTransaction(uint32_t flags) { 660 ATRACE_CALL(); 661 662 const Layer::State& s(getDrawingState()); 663 const Layer::State& c(getCurrentState()); 664 665 const bool sizeChanged = (c.requested.w != s.requested.w) || 666 (c.requested.h != s.requested.h); 667 668 if (sizeChanged) { 669 // the size changed, we need to ask our client to request a new buffer 670 ALOGD_IF(DEBUG_RESIZE, 671 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 672 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 673 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n" 674 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 675 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 676 this, getName().string(), mCurrentTransform, mCurrentScalingMode, 677 c.active.w, c.active.h, 678 c.active.crop.left, 679 c.active.crop.top, 680 c.active.crop.right, 681 c.active.crop.bottom, 682 c.active.crop.getWidth(), 683 c.active.crop.getHeight(), 684 c.requested.w, c.requested.h, 685 c.requested.crop.left, 686 c.requested.crop.top, 687 c.requested.crop.right, 688 c.requested.crop.bottom, 689 c.requested.crop.getWidth(), 690 c.requested.crop.getHeight(), 691 s.active.w, s.active.h, 692 s.active.crop.left, 693 s.active.crop.top, 694 s.active.crop.right, 695 s.active.crop.bottom, 696 s.active.crop.getWidth(), 697 s.active.crop.getHeight(), 698 s.requested.w, s.requested.h, 699 s.requested.crop.left, 700 s.requested.crop.top, 701 s.requested.crop.right, 702 s.requested.crop.bottom, 703 s.requested.crop.getWidth(), 704 s.requested.crop.getHeight()); 705 706 // record the new size, form this point on, when the client request 707 // a buffer, it'll get the new size. 708 mSurfaceFlingerConsumer->setDefaultBufferSize( 709 c.requested.w, c.requested.h); 710 } 711 712 if (!isFixedSize()) { 713 714 const bool resizePending = (c.requested.w != c.active.w) || 715 (c.requested.h != c.active.h); 716 717 if (resizePending) { 718 // don't let Layer::doTransaction update the drawing state 719 // if we have a pending resize, unless we are in fixed-size mode. 720 // the drawing state will be updated only once we receive a buffer 721 // with the correct size. 722 // 723 // in particular, we want to make sure the clip (which is part 724 // of the geometry state) is latched together with the size but is 725 // latched immediately when no resizing is involved. 726 727 flags |= eDontUpdateGeometryState; 728 } 729 } 730 731 // always set active to requested, unless we're asked not to 732 // this is used by Layer, which special cases resizes. 733 if (flags & eDontUpdateGeometryState) { 734 } else { 735 Layer::State& editCurrentState(getCurrentState()); 736 editCurrentState.active = c.requested; 737 } 738 739 if (s.active != c.active) { 740 // invalidate and recompute the visible regions if needed 741 flags |= Layer::eVisibleRegion; 742 } 743 744 if (c.sequence != s.sequence) { 745 // invalidate and recompute the visible regions if needed 746 flags |= eVisibleRegion; 747 this->contentDirty = true; 748 749 // we may use linear filtering, if the matrix scales us 750 const uint8_t type = c.transform.getType(); 751 mNeedsFiltering = (!c.transform.preserveRects() || 752 (type >= Transform::SCALE)); 753 } 754 755 // Commit the transaction 756 commitTransaction(); 757 return flags; 758} 759 760void Layer::commitTransaction() { 761 mDrawingState = mCurrentState; 762} 763 764uint32_t Layer::getTransactionFlags(uint32_t flags) { 765 return android_atomic_and(~flags, &mTransactionFlags) & flags; 766} 767 768uint32_t Layer::setTransactionFlags(uint32_t flags) { 769 return android_atomic_or(flags, &mTransactionFlags); 770} 771 772bool Layer::setPosition(float x, float y) { 773 if (mCurrentState.transform.tx() == x && mCurrentState.transform.ty() == y) 774 return false; 775 mCurrentState.sequence++; 776 mCurrentState.transform.set(x, y); 777 setTransactionFlags(eTransactionNeeded); 778 return true; 779} 780bool Layer::setLayer(uint32_t z) { 781 if (mCurrentState.z == z) 782 return false; 783 mCurrentState.sequence++; 784 mCurrentState.z = z; 785 setTransactionFlags(eTransactionNeeded); 786 return true; 787} 788bool Layer::setSize(uint32_t w, uint32_t h) { 789 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 790 return false; 791 mCurrentState.requested.w = w; 792 mCurrentState.requested.h = h; 793 setTransactionFlags(eTransactionNeeded); 794 return true; 795} 796bool Layer::setAlpha(uint8_t alpha) { 797 if (mCurrentState.alpha == alpha) 798 return false; 799 mCurrentState.sequence++; 800 mCurrentState.alpha = alpha; 801 setTransactionFlags(eTransactionNeeded); 802 return true; 803} 804bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 805 mCurrentState.sequence++; 806 mCurrentState.transform.set( 807 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); 808 setTransactionFlags(eTransactionNeeded); 809 return true; 810} 811bool Layer::setTransparentRegionHint(const Region& transparent) { 812 mCurrentState.requestedTransparentRegion = transparent; 813 setTransactionFlags(eTransactionNeeded); 814 return true; 815} 816bool Layer::setFlags(uint8_t flags, uint8_t mask) { 817 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 818 if (mCurrentState.flags == newFlags) 819 return false; 820 mCurrentState.sequence++; 821 mCurrentState.flags = newFlags; 822 setTransactionFlags(eTransactionNeeded); 823 return true; 824} 825bool Layer::setCrop(const Rect& crop) { 826 if (mCurrentState.requested.crop == crop) 827 return false; 828 mCurrentState.sequence++; 829 mCurrentState.requested.crop = crop; 830 setTransactionFlags(eTransactionNeeded); 831 return true; 832} 833 834bool Layer::setLayerStack(uint32_t layerStack) { 835 if (mCurrentState.layerStack == layerStack) 836 return false; 837 mCurrentState.sequence++; 838 mCurrentState.layerStack = layerStack; 839 setTransactionFlags(eTransactionNeeded); 840 return true; 841} 842 843// ---------------------------------------------------------------------------- 844// pageflip handling... 845// ---------------------------------------------------------------------------- 846 847bool Layer::onPreComposition() { 848 mRefreshPending = false; 849 return mQueuedFrames > 0; 850} 851 852void Layer::onPostComposition() { 853 if (mFrameLatencyNeeded) { 854 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 855 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 856 857 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 858 if (frameReadyFence->isValid()) { 859 mFrameTracker.setFrameReadyFence(frameReadyFence); 860 } else { 861 // There was no fence for this frame, so assume that it was ready 862 // to be presented at the desired present time. 863 mFrameTracker.setFrameReadyTime(desiredPresentTime); 864 } 865 866 const HWComposer& hwc = mFlinger->getHwComposer(); 867 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 868 if (presentFence->isValid()) { 869 mFrameTracker.setActualPresentFence(presentFence); 870 } else { 871 // The HWC doesn't support present fences, so use the refresh 872 // timestamp instead. 873 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 874 mFrameTracker.setActualPresentTime(presentTime); 875 } 876 877 mFrameTracker.advanceFrame(); 878 mFrameLatencyNeeded = false; 879 } 880} 881 882bool Layer::isVisible() const { 883 const Layer::State& s(mDrawingState); 884 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha 885 && (mActiveBuffer != NULL); 886} 887 888Region Layer::latchBuffer(bool& recomputeVisibleRegions) 889{ 890 ATRACE_CALL(); 891 892 Region outDirtyRegion; 893 if (mQueuedFrames > 0) { 894 895 // if we've already called updateTexImage() without going through 896 // a composition step, we have to skip this layer at this point 897 // because we cannot call updateTeximage() without a corresponding 898 // compositionComplete() call. 899 // we'll trigger an update in onPreComposition(). 900 if (mRefreshPending) { 901 return outDirtyRegion; 902 } 903 904 // Capture the old state of the layer for comparisons later 905 const bool oldOpacity = isOpaque(); 906 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 907 908 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 909 Layer::State& front; 910 Layer::State& current; 911 bool& recomputeVisibleRegions; 912 Reject(Layer::State& front, Layer::State& current, 913 bool& recomputeVisibleRegions) 914 : front(front), current(current), 915 recomputeVisibleRegions(recomputeVisibleRegions) { 916 } 917 918 virtual bool reject(const sp<GraphicBuffer>& buf, 919 const IGraphicBufferConsumer::BufferItem& item) { 920 if (buf == NULL) { 921 return false; 922 } 923 924 uint32_t bufWidth = buf->getWidth(); 925 uint32_t bufHeight = buf->getHeight(); 926 927 // check that we received a buffer of the right size 928 // (Take the buffer's orientation into account) 929 if (item.mTransform & Transform::ROT_90) { 930 swap(bufWidth, bufHeight); 931 } 932 933 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 934 if (front.active != front.requested) { 935 936 if (isFixedSize || 937 (bufWidth == front.requested.w && 938 bufHeight == front.requested.h)) 939 { 940 // Here we pretend the transaction happened by updating the 941 // current and drawing states. Drawing state is only accessed 942 // in this thread, no need to have it locked 943 front.active = front.requested; 944 945 // We also need to update the current state so that 946 // we don't end-up overwriting the drawing state with 947 // this stale current state during the next transaction 948 // 949 // NOTE: We don't need to hold the transaction lock here 950 // because State::active is only accessed from this thread. 951 current.active = front.active; 952 953 // recompute visible region 954 recomputeVisibleRegions = true; 955 } 956 957 ALOGD_IF(DEBUG_RESIZE, 958 "latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 959 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 960 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 961 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 962 front.active.w, front.active.h, 963 front.active.crop.left, 964 front.active.crop.top, 965 front.active.crop.right, 966 front.active.crop.bottom, 967 front.active.crop.getWidth(), 968 front.active.crop.getHeight(), 969 front.requested.w, front.requested.h, 970 front.requested.crop.left, 971 front.requested.crop.top, 972 front.requested.crop.right, 973 front.requested.crop.bottom, 974 front.requested.crop.getWidth(), 975 front.requested.crop.getHeight()); 976 } 977 978 if (!isFixedSize) { 979 if (front.active.w != bufWidth || 980 front.active.h != bufHeight) { 981 // reject this buffer 982 return true; 983 } 984 } 985 986 // if the transparent region has changed (this test is 987 // conservative, but that's fine, worst case we're doing 988 // a bit of extra work), we latch the new one and we 989 // trigger a visible-region recompute. 990 if (!front.activeTransparentRegion.isTriviallyEqual( 991 front.requestedTransparentRegion)) { 992 front.activeTransparentRegion = front.requestedTransparentRegion; 993 994 // We also need to update the current state so that 995 // we don't end-up overwriting the drawing state with 996 // this stale current state during the next transaction 997 // 998 // NOTE: We don't need to hold the transaction lock here 999 // because State::active is only accessed from this thread. 1000 current.activeTransparentRegion = front.activeTransparentRegion; 1001 1002 // recompute visible region 1003 recomputeVisibleRegions = true; 1004 } 1005 1006 return false; 1007 } 1008 }; 1009 1010 1011 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions); 1012 1013 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r); 1014 if (updateResult == BufferQueue::PRESENT_LATER) { 1015 // Producer doesn't want buffer to be displayed yet. Signal a 1016 // layer update so we check again at the next opportunity. 1017 mFlinger->signalLayerUpdate(); 1018 return outDirtyRegion; 1019 } 1020 1021 // Decrement the queued-frames count. Signal another event if we 1022 // have more frames pending. 1023 if (android_atomic_dec(&mQueuedFrames) > 1) { 1024 mFlinger->signalLayerUpdate(); 1025 } 1026 1027 if (updateResult != NO_ERROR) { 1028 // something happened! 1029 recomputeVisibleRegions = true; 1030 return outDirtyRegion; 1031 } 1032 1033 // update the active buffer 1034 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 1035 if (mActiveBuffer == NULL) { 1036 // this can only happen if the very first buffer was rejected. 1037 return outDirtyRegion; 1038 } 1039 1040 mRefreshPending = true; 1041 mFrameLatencyNeeded = true; 1042 if (oldActiveBuffer == NULL) { 1043 // the first time we receive a buffer, we need to trigger a 1044 // geometry invalidation. 1045 recomputeVisibleRegions = true; 1046 } 1047 1048 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 1049 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 1050 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 1051 if ((crop != mCurrentCrop) || 1052 (transform != mCurrentTransform) || 1053 (scalingMode != mCurrentScalingMode)) 1054 { 1055 mCurrentCrop = crop; 1056 mCurrentTransform = transform; 1057 mCurrentScalingMode = scalingMode; 1058 recomputeVisibleRegions = true; 1059 } 1060 1061 if (oldActiveBuffer != NULL) { 1062 uint32_t bufWidth = mActiveBuffer->getWidth(); 1063 uint32_t bufHeight = mActiveBuffer->getHeight(); 1064 if (bufWidth != uint32_t(oldActiveBuffer->width) || 1065 bufHeight != uint32_t(oldActiveBuffer->height)) { 1066 recomputeVisibleRegions = true; 1067 } 1068 } 1069 1070 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 1071 if (oldOpacity != isOpaque()) { 1072 recomputeVisibleRegions = true; 1073 } 1074 1075 // FIXME: postedRegion should be dirty & bounds 1076 const Layer::State& s(getDrawingState()); 1077 Region dirtyRegion(Rect(s.active.w, s.active.h)); 1078 1079 // transform the dirty region to window-manager space 1080 outDirtyRegion = (s.transform.transform(dirtyRegion)); 1081 } 1082 return outDirtyRegion; 1083} 1084 1085uint32_t Layer::getEffectiveUsage(uint32_t usage) const 1086{ 1087 // TODO: should we do something special if mSecure is set? 1088 if (mProtectedByApp) { 1089 // need a hardware-protected path to external video sink 1090 usage |= GraphicBuffer::USAGE_PROTECTED; 1091 } 1092 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 1093 return usage; 1094} 1095 1096void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 1097 uint32_t orientation = 0; 1098 if (!mFlinger->mDebugDisableTransformHint) { 1099 // The transform hint is used to improve performance, but we can 1100 // only have a single transform hint, it cannot 1101 // apply to all displays. 1102 const Transform& planeTransform(hw->getTransform()); 1103 orientation = planeTransform.getOrientation(); 1104 if (orientation & Transform::ROT_INVALID) { 1105 orientation = 0; 1106 } 1107 } 1108 mSurfaceFlingerConsumer->setTransformHint(orientation); 1109} 1110 1111// ---------------------------------------------------------------------------- 1112// debugging 1113// ---------------------------------------------------------------------------- 1114 1115void Layer::dump(String8& result, Colorizer& colorizer) const 1116{ 1117 const Layer::State& s(getDrawingState()); 1118 1119 colorizer.colorize(result, Colorizer::GREEN); 1120 result.appendFormat( 1121 "+ %s %p (%s)\n", 1122 getTypeId(), this, getName().string()); 1123 colorizer.reset(result); 1124 1125 s.activeTransparentRegion.dump(result, "transparentRegion"); 1126 visibleRegion.dump(result, "visibleRegion"); 1127 sp<Client> client(mClientRef.promote()); 1128 1129 result.appendFormat( " " 1130 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), " 1131 "isOpaque=%1d, invalidate=%1d, " 1132 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 1133 " client=%p\n", 1134 s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h, 1135 s.active.crop.left, s.active.crop.top, 1136 s.active.crop.right, s.active.crop.bottom, 1137 isOpaque(), contentDirty, 1138 s.alpha, s.flags, 1139 s.transform[0][0], s.transform[0][1], 1140 s.transform[1][0], s.transform[1][1], 1141 client.get()); 1142 1143 sp<const GraphicBuffer> buf0(mActiveBuffer); 1144 uint32_t w0=0, h0=0, s0=0, f0=0; 1145 if (buf0 != 0) { 1146 w0 = buf0->getWidth(); 1147 h0 = buf0->getHeight(); 1148 s0 = buf0->getStride(); 1149 f0 = buf0->format; 1150 } 1151 result.appendFormat( 1152 " " 1153 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 1154 " queued-frames=%d, mRefreshPending=%d\n", 1155 mFormat, w0, h0, s0,f0, 1156 mQueuedFrames, mRefreshPending); 1157 1158 if (mSurfaceFlingerConsumer != 0) { 1159 mSurfaceFlingerConsumer->dump(result, " "); 1160 } 1161} 1162 1163void Layer::dumpStats(String8& result) const { 1164 mFrameTracker.dump(result); 1165} 1166 1167void Layer::clearStats() { 1168 mFrameTracker.clear(); 1169} 1170 1171void Layer::logFrameStats() { 1172 mFrameTracker.logAndResetStats(mName); 1173} 1174 1175// --------------------------------------------------------------------------- 1176 1177Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 1178 const sp<Layer>& layer) 1179 : mFlinger(flinger), mLayer(layer) { 1180} 1181 1182Layer::LayerCleaner::~LayerCleaner() { 1183 // destroy client resources 1184 mFlinger->onLayerDestroyed(mLayer); 1185} 1186 1187// --------------------------------------------------------------------------- 1188}; // namespace android 1189 1190#if defined(__gl_h_) 1191#error "don't include gl/gl.h in this file" 1192#endif 1193 1194#if defined(__gl2_h_) 1195#error "don't include gl2/gl2.h in this file" 1196#endif 1197