Layer.cpp revision 13f01cbdbd34779a234bc674df79e23672fd5c0b
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.sequence++; 885 mCurrentState.transparentRegion = transparent; 886 setTransactionFlags(eTransactionNeeded); 887 return true; 888} 889bool Layer::setFlags(uint8_t flags, uint8_t mask) { 890 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 891 if (mCurrentState.flags == newFlags) 892 return false; 893 mCurrentState.sequence++; 894 mCurrentState.flags = newFlags; 895 setTransactionFlags(eTransactionNeeded); 896 return true; 897} 898bool Layer::setCrop(const Rect& crop) { 899 if (mCurrentState.requested.crop == crop) 900 return false; 901 mCurrentState.sequence++; 902 mCurrentState.requested.crop = crop; 903 setTransactionFlags(eTransactionNeeded); 904 return true; 905} 906 907bool Layer::setLayerStack(uint32_t layerStack) { 908 if (mCurrentState.layerStack == layerStack) 909 return false; 910 mCurrentState.sequence++; 911 mCurrentState.layerStack = layerStack; 912 setTransactionFlags(eTransactionNeeded); 913 return true; 914} 915 916// ---------------------------------------------------------------------------- 917// pageflip handling... 918// ---------------------------------------------------------------------------- 919 920bool Layer::onPreComposition() { 921 mRefreshPending = false; 922 return mQueuedFrames > 0; 923} 924 925void Layer::onPostComposition() { 926 if (mFrameLatencyNeeded) { 927 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 928 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 929 930 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 931 if (frameReadyFence->isValid()) { 932 mFrameTracker.setFrameReadyFence(frameReadyFence); 933 } else { 934 // There was no fence for this frame, so assume that it was ready 935 // to be presented at the desired present time. 936 mFrameTracker.setFrameReadyTime(desiredPresentTime); 937 } 938 939 const HWComposer& hwc = mFlinger->getHwComposer(); 940 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 941 if (presentFence->isValid()) { 942 mFrameTracker.setActualPresentFence(presentFence); 943 } else { 944 // The HWC doesn't support present fences, so use the refresh 945 // timestamp instead. 946 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 947 mFrameTracker.setActualPresentTime(presentTime); 948 } 949 950 mFrameTracker.advanceFrame(); 951 mFrameLatencyNeeded = false; 952 } 953} 954 955bool Layer::isVisible() const { 956 const Layer::State& s(mDrawingState); 957 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha 958 && (mActiveBuffer != NULL); 959} 960 961Region Layer::latchBuffer(bool& recomputeVisibleRegions) 962{ 963 ATRACE_CALL(); 964 965 Region outDirtyRegion; 966 if (mQueuedFrames > 0) { 967 968 // if we've already called updateTexImage() without going through 969 // a composition step, we have to skip this layer at this point 970 // because we cannot call updateTeximage() without a corresponding 971 // compositionComplete() call. 972 // we'll trigger an update in onPreComposition(). 973 if (mRefreshPending) { 974 return outDirtyRegion; 975 } 976 977 // Capture the old state of the layer for comparisons later 978 const bool oldOpacity = isOpaque(); 979 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 980 981 // signal another event if we have more frames pending 982 if (android_atomic_dec(&mQueuedFrames) > 1) { 983 mFlinger->signalLayerUpdate(); 984 } 985 986 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 987 Layer::State& front; 988 Layer::State& current; 989 bool& recomputeVisibleRegions; 990 Reject(Layer::State& front, Layer::State& current, 991 bool& recomputeVisibleRegions) 992 : front(front), current(current), 993 recomputeVisibleRegions(recomputeVisibleRegions) { 994 } 995 996 virtual bool reject(const sp<GraphicBuffer>& buf, 997 const BufferQueue::BufferItem& item) { 998 if (buf == NULL) { 999 return false; 1000 } 1001 1002 uint32_t bufWidth = buf->getWidth(); 1003 uint32_t bufHeight = buf->getHeight(); 1004 1005 // check that we received a buffer of the right size 1006 // (Take the buffer's orientation into account) 1007 if (item.mTransform & Transform::ROT_90) { 1008 swap(bufWidth, bufHeight); 1009 } 1010 1011 1012 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1013 if (front.active != front.requested) { 1014 1015 if (isFixedSize || 1016 (bufWidth == front.requested.w && 1017 bufHeight == front.requested.h)) 1018 { 1019 // Here we pretend the transaction happened by updating the 1020 // current and drawing states. Drawing state is only accessed 1021 // in this thread, no need to have it locked 1022 front.active = front.requested; 1023 1024 // We also need to update the current state so that 1025 // we don't end-up overwriting the drawing state with 1026 // this stale current state during the next transaction 1027 // 1028 // NOTE: We don't need to hold the transaction lock here 1029 // because State::active is only accessed from this thread. 1030 current.active = front.active; 1031 1032 // recompute visible region 1033 recomputeVisibleRegions = true; 1034 } 1035 1036 ALOGD_IF(DEBUG_RESIZE, 1037 "latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 1038 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1039 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 1040 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 1041 front.active.w, front.active.h, 1042 front.active.crop.left, 1043 front.active.crop.top, 1044 front.active.crop.right, 1045 front.active.crop.bottom, 1046 front.active.crop.getWidth(), 1047 front.active.crop.getHeight(), 1048 front.requested.w, front.requested.h, 1049 front.requested.crop.left, 1050 front.requested.crop.top, 1051 front.requested.crop.right, 1052 front.requested.crop.bottom, 1053 front.requested.crop.getWidth(), 1054 front.requested.crop.getHeight()); 1055 } 1056 1057 if (!isFixedSize) { 1058 if (front.active.w != bufWidth || 1059 front.active.h != bufHeight) { 1060 // reject this buffer 1061 return true; 1062 } 1063 } 1064 return false; 1065 } 1066 }; 1067 1068 1069 Reject r(mDrawingState, currentState(), recomputeVisibleRegions); 1070 1071 if (mSurfaceFlingerConsumer->updateTexImage(&r) != NO_ERROR) { 1072 // something happened! 1073 recomputeVisibleRegions = true; 1074 return outDirtyRegion; 1075 } 1076 1077 // update the active buffer 1078 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 1079 if (mActiveBuffer == NULL) { 1080 // this can only happen if the very first buffer was rejected. 1081 return outDirtyRegion; 1082 } 1083 1084 mRefreshPending = true; 1085 mFrameLatencyNeeded = true; 1086 if (oldActiveBuffer == NULL) { 1087 // the first time we receive a buffer, we need to trigger a 1088 // geometry invalidation. 1089 recomputeVisibleRegions = true; 1090 } 1091 1092 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 1093 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 1094 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 1095 if ((crop != mCurrentCrop) || 1096 (transform != mCurrentTransform) || 1097 (scalingMode != mCurrentScalingMode)) 1098 { 1099 mCurrentCrop = crop; 1100 mCurrentTransform = transform; 1101 mCurrentScalingMode = scalingMode; 1102 recomputeVisibleRegions = true; 1103 } 1104 1105 if (oldActiveBuffer != NULL) { 1106 uint32_t bufWidth = mActiveBuffer->getWidth(); 1107 uint32_t bufHeight = mActiveBuffer->getHeight(); 1108 if (bufWidth != uint32_t(oldActiveBuffer->width) || 1109 bufHeight != uint32_t(oldActiveBuffer->height)) { 1110 recomputeVisibleRegions = true; 1111 } 1112 } 1113 1114 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 1115 if (oldOpacity != isOpaque()) { 1116 recomputeVisibleRegions = true; 1117 } 1118 1119 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 1120 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 1121 1122 // FIXME: postedRegion should be dirty & bounds 1123 const Layer::State& front(drawingState()); 1124 Region dirtyRegion(Rect(front.active.w, front.active.h)); 1125 1126 // transform the dirty region to window-manager space 1127 outDirtyRegion = (front.transform.transform(dirtyRegion)); 1128 } 1129 return outDirtyRegion; 1130} 1131 1132uint32_t Layer::getEffectiveUsage(uint32_t usage) const 1133{ 1134 // TODO: should we do something special if mSecure is set? 1135 if (mProtectedByApp) { 1136 // need a hardware-protected path to external video sink 1137 usage |= GraphicBuffer::USAGE_PROTECTED; 1138 } 1139 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 1140 return usage; 1141} 1142 1143void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 1144 uint32_t orientation = 0; 1145 if (!mFlinger->mDebugDisableTransformHint) { 1146 // The transform hint is used to improve performance, but we can 1147 // only have a single transform hint, it cannot 1148 // apply to all displays. 1149 const Transform& planeTransform(hw->getTransform()); 1150 orientation = planeTransform.getOrientation(); 1151 if (orientation & Transform::ROT_INVALID) { 1152 orientation = 0; 1153 } 1154 } 1155 mSurfaceFlingerConsumer->setTransformHint(orientation); 1156} 1157 1158// ---------------------------------------------------------------------------- 1159// debugging 1160// ---------------------------------------------------------------------------- 1161 1162void Layer::dump(String8& result, char* buffer, size_t SIZE) const 1163{ 1164 const Layer::State& s(drawingState()); 1165 1166 snprintf(buffer, SIZE, 1167 "+ %s %p (%s)\n", 1168 getTypeId(), this, getName().string()); 1169 result.append(buffer); 1170 1171 s.transparentRegion.dump(result, "transparentRegion"); 1172 visibleRegion.dump(result, "visibleRegion"); 1173 sp<Client> client(mClientRef.promote()); 1174 1175 snprintf(buffer, SIZE, 1176 " " 1177 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), " 1178 "isOpaque=%1d, invalidate=%1d, " 1179 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 1180 " client=%p\n", 1181 s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h, 1182 s.active.crop.left, s.active.crop.top, 1183 s.active.crop.right, s.active.crop.bottom, 1184 isOpaque(), contentDirty, 1185 s.alpha, s.flags, 1186 s.transform[0][0], s.transform[0][1], 1187 s.transform[1][0], s.transform[1][1], 1188 client.get()); 1189 result.append(buffer); 1190 1191 sp<const GraphicBuffer> buf0(mActiveBuffer); 1192 uint32_t w0=0, h0=0, s0=0, f0=0; 1193 if (buf0 != 0) { 1194 w0 = buf0->getWidth(); 1195 h0 = buf0->getHeight(); 1196 s0 = buf0->getStride(); 1197 f0 = buf0->format; 1198 } 1199 snprintf(buffer, SIZE, 1200 " " 1201 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 1202 " queued-frames=%d, mRefreshPending=%d\n", 1203 mFormat, w0, h0, s0,f0, 1204 mQueuedFrames, mRefreshPending); 1205 1206 result.append(buffer); 1207 1208 if (mSurfaceFlingerConsumer != 0) { 1209 mSurfaceFlingerConsumer->dump(result, " ", buffer, SIZE); 1210 } 1211} 1212 1213 1214void Layer::shortDump(String8& result, char* scratch, size_t size) const { 1215 Layer::dump(result, scratch, size); 1216} 1217 1218void Layer::dumpStats(String8& result, char* buffer, size_t SIZE) const { 1219 mFrameTracker.dump(result); 1220} 1221 1222void Layer::clearStats() { 1223 mFrameTracker.clear(); 1224} 1225 1226// --------------------------------------------------------------------------- 1227 1228Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 1229 const sp<Layer>& layer) 1230 : mFlinger(flinger), mLayer(layer) { 1231} 1232 1233Layer::LayerCleaner::~LayerCleaner() { 1234 // destroy client resources 1235 mFlinger->onLayerDestroyed(mLayer); 1236} 1237 1238// --------------------------------------------------------------------------- 1239 1240 1241}; // namespace android 1242