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