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