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