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