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