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