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 49 namespace android { 50 51 // --------------------------------------------------------------------------- 52 53 int32_t Layer::sSequence = 1; 54 55 Layer::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 108 void 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 131 Layer::~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 143 void 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 151 void 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) 159 void Layer::onRemoved() { 160 mSurfaceFlingerConsumer->abandon(); 161 } 162 163 // --------------------------------------------------------------------------- 164 // set-up 165 // --------------------------------------------------------------------------- 166 167 String8 Layer::getName() const { 168 return mName; 169 } 170 171 status_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 206 sp<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 234 sp<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 251 Rect 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 268 uint32_t Layer::getContentTransform() const { 269 return mCurrentTransform; 270 } 271 272 Rect 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 281 Rect 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 346 void 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 397 void 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 413 void 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 436 void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const { 437 onDraw(hw, clip); 438 } 439 440 void Layer::draw(const sp<const DisplayDevice>& hw) { 441 onDraw( hw, Region(hw->bounds()) ); 442 } 443 444 void 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 525 void 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 542 void Layer::clearWithOpenGL( 543 const sp<const DisplayDevice>& hw, const Region& clip) const { 544 clearWithOpenGL(hw, clip, 0,0,0,0); 545 } 546 547 void 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 629 void Layer::setFiltering(bool filtering) { 630 mFiltering = filtering; 631 } 632 633 bool 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 644 bool 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 659 void 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 679 bool 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 692 bool Layer::isProtected() const 693 { 694 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 695 return (activeBuffer != 0) && 696 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 697 } 698 699 bool Layer::isFixedSize() const { 700 return mCurrentScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 701 } 702 703 bool Layer::isCropped() const { 704 return !mCurrentCrop.isEmpty(); 705 } 706 707 bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const { 708 return mNeedsFiltering || hw->needsFiltering(); 709 } 710 711 void Layer::setVisibleRegion(const Region& visibleRegion) { 712 // always called from main thread 713 this->visibleRegion = visibleRegion; 714 } 715 716 void Layer::setCoveredRegion(const Region& coveredRegion) { 717 // always called from main thread 718 this->coveredRegion = coveredRegion; 719 } 720 721 void Layer::setVisibleNonTransparentRegion(const Region& 722 setVisibleNonTransparentRegion) { 723 // always called from main thread 724 this->visibleNonTransparentRegion = setVisibleNonTransparentRegion; 725 } 726 727 // ---------------------------------------------------------------------------- 728 // transaction 729 // ---------------------------------------------------------------------------- 730 731 uint32_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 832 void Layer::commitTransaction() { 833 mDrawingState = mCurrentState; 834 } 835 836 uint32_t Layer::getTransactionFlags(uint32_t flags) { 837 return android_atomic_and(~flags, &mTransactionFlags) & flags; 838 } 839 840 uint32_t Layer::setTransactionFlags(uint32_t flags) { 841 return android_atomic_or(flags, &mTransactionFlags); 842 } 843 844 bool 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 } 852 bool 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 } 860 bool 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 } 868 bool 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 } 876 bool 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 } 883 bool Layer::setTransparentRegionHint(const Region& transparent) { 884 mCurrentState.requestedTransparentRegion = transparent; 885 setTransactionFlags(eTransactionNeeded); 886 return true; 887 } 888 bool Layer::setFlags(uint8_t flags, uint8_t mask) { 889 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 890 if (mCurrentState.flags == newFlags) 891 return false; 892 mCurrentState.sequence++; 893 mCurrentState.flags = newFlags; 894 setTransactionFlags(eTransactionNeeded); 895 return true; 896 } 897 bool Layer::setCrop(const Rect& crop) { 898 if (mCurrentState.requested.crop == crop) 899 return false; 900 mCurrentState.sequence++; 901 mCurrentState.requested.crop = crop; 902 setTransactionFlags(eTransactionNeeded); 903 return true; 904 } 905 906 bool Layer::setLayerStack(uint32_t layerStack) { 907 if (mCurrentState.layerStack == layerStack) 908 return false; 909 mCurrentState.sequence++; 910 mCurrentState.layerStack = layerStack; 911 setTransactionFlags(eTransactionNeeded); 912 return true; 913 } 914 915 // ---------------------------------------------------------------------------- 916 // pageflip handling... 917 // ---------------------------------------------------------------------------- 918 919 bool Layer::onPreComposition() { 920 mRefreshPending = false; 921 return mQueuedFrames > 0; 922 } 923 924 void Layer::onPostComposition() { 925 if (mFrameLatencyNeeded) { 926 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 927 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 928 929 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 930 if (frameReadyFence->isValid()) { 931 mFrameTracker.setFrameReadyFence(frameReadyFence); 932 } else { 933 // There was no fence for this frame, so assume that it was ready 934 // to be presented at the desired present time. 935 mFrameTracker.setFrameReadyTime(desiredPresentTime); 936 } 937 938 const HWComposer& hwc = mFlinger->getHwComposer(); 939 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 940 if (presentFence->isValid()) { 941 mFrameTracker.setActualPresentFence(presentFence); 942 } else { 943 // The HWC doesn't support present fences, so use the refresh 944 // timestamp instead. 945 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 946 mFrameTracker.setActualPresentTime(presentTime); 947 } 948 949 mFrameTracker.advanceFrame(); 950 mFrameLatencyNeeded = false; 951 } 952 } 953 954 bool Layer::isVisible() const { 955 const Layer::State& s(mDrawingState); 956 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha 957 && (mActiveBuffer != NULL); 958 } 959 960 Region Layer::latchBuffer(bool& recomputeVisibleRegions) 961 { 962 ATRACE_CALL(); 963 964 Region outDirtyRegion; 965 if (mQueuedFrames > 0) { 966 967 // if we've already called updateTexImage() without going through 968 // a composition step, we have to skip this layer at this point 969 // because we cannot call updateTeximage() without a corresponding 970 // compositionComplete() call. 971 // we'll trigger an update in onPreComposition(). 972 if (mRefreshPending) { 973 return outDirtyRegion; 974 } 975 976 // Capture the old state of the layer for comparisons later 977 const bool oldOpacity = isOpaque(); 978 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 979 980 // signal another event if we have more frames pending 981 if (android_atomic_dec(&mQueuedFrames) > 1) { 982 mFlinger->signalLayerUpdate(); 983 } 984 985 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 986 Layer::State& front; 987 Layer::State& current; 988 bool& recomputeVisibleRegions; 989 Reject(Layer::State& front, Layer::State& current, 990 bool& recomputeVisibleRegions) 991 : front(front), current(current), 992 recomputeVisibleRegions(recomputeVisibleRegions) { 993 } 994 995 virtual bool reject(const sp<GraphicBuffer>& buf, 996 const BufferQueue::BufferItem& item) { 997 if (buf == NULL) { 998 return false; 999 } 1000 1001 uint32_t bufWidth = buf->getWidth(); 1002 uint32_t bufHeight = buf->getHeight(); 1003 1004 // check that we received a buffer of the right size 1005 // (Take the buffer's orientation into account) 1006 if (item.mTransform & Transform::ROT_90) { 1007 swap(bufWidth, bufHeight); 1008 } 1009 1010 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1011 if (front.active != front.requested) { 1012 1013 if (isFixedSize || 1014 (bufWidth == front.requested.w && 1015 bufHeight == front.requested.h)) 1016 { 1017 // Here we pretend the transaction happened by updating the 1018 // current and drawing states. Drawing state is only accessed 1019 // in this thread, no need to have it locked 1020 front.active = front.requested; 1021 1022 // We also need to update the current state so that 1023 // we don't end-up overwriting the drawing state with 1024 // this stale current state during the next transaction 1025 // 1026 // NOTE: We don't need to hold the transaction lock here 1027 // because State::active is only accessed from this thread. 1028 current.active = front.active; 1029 1030 // recompute visible region 1031 recomputeVisibleRegions = true; 1032 } 1033 1034 ALOGD_IF(DEBUG_RESIZE, 1035 "latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 1036 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1037 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 1038 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 1039 front.active.w, front.active.h, 1040 front.active.crop.left, 1041 front.active.crop.top, 1042 front.active.crop.right, 1043 front.active.crop.bottom, 1044 front.active.crop.getWidth(), 1045 front.active.crop.getHeight(), 1046 front.requested.w, front.requested.h, 1047 front.requested.crop.left, 1048 front.requested.crop.top, 1049 front.requested.crop.right, 1050 front.requested.crop.bottom, 1051 front.requested.crop.getWidth(), 1052 front.requested.crop.getHeight()); 1053 } 1054 1055 if (!isFixedSize) { 1056 if (front.active.w != bufWidth || 1057 front.active.h != bufHeight) { 1058 // reject this buffer 1059 return true; 1060 } 1061 } 1062 1063 // if the transparent region has changed (this test is 1064 // conservative, but that's fine, worst case we're doing 1065 // a bit of extra work), we latch the new one and we 1066 // trigger a visible-region recompute. 1067 if (!front.activeTransparentRegion.isTriviallyEqual( 1068 front.requestedTransparentRegion)) { 1069 front.activeTransparentRegion = front.requestedTransparentRegion; 1070 1071 // We also need to update the current state so that 1072 // we don't end-up overwriting the drawing state with 1073 // this stale current state during the next transaction 1074 // 1075 // NOTE: We don't need to hold the transaction lock here 1076 // because State::active is only accessed from this thread. 1077 current.activeTransparentRegion = front.activeTransparentRegion; 1078 1079 // recompute visible region 1080 recomputeVisibleRegions = true; 1081 } 1082 1083 return false; 1084 } 1085 }; 1086 1087 1088 Reject r(mDrawingState, currentState(), recomputeVisibleRegions); 1089 1090 if (mSurfaceFlingerConsumer->updateTexImage(&r) != NO_ERROR) { 1091 // something happened! 1092 recomputeVisibleRegions = true; 1093 return outDirtyRegion; 1094 } 1095 1096 // update the active buffer 1097 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 1098 if (mActiveBuffer == NULL) { 1099 // this can only happen if the very first buffer was rejected. 1100 return outDirtyRegion; 1101 } 1102 1103 mRefreshPending = true; 1104 mFrameLatencyNeeded = true; 1105 if (oldActiveBuffer == NULL) { 1106 // the first time we receive a buffer, we need to trigger a 1107 // geometry invalidation. 1108 recomputeVisibleRegions = true; 1109 } 1110 1111 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 1112 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 1113 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 1114 if ((crop != mCurrentCrop) || 1115 (transform != mCurrentTransform) || 1116 (scalingMode != mCurrentScalingMode)) 1117 { 1118 mCurrentCrop = crop; 1119 mCurrentTransform = transform; 1120 mCurrentScalingMode = scalingMode; 1121 recomputeVisibleRegions = true; 1122 } 1123 1124 if (oldActiveBuffer != NULL) { 1125 uint32_t bufWidth = mActiveBuffer->getWidth(); 1126 uint32_t bufHeight = mActiveBuffer->getHeight(); 1127 if (bufWidth != uint32_t(oldActiveBuffer->width) || 1128 bufHeight != uint32_t(oldActiveBuffer->height)) { 1129 recomputeVisibleRegions = true; 1130 } 1131 } 1132 1133 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 1134 if (oldOpacity != isOpaque()) { 1135 recomputeVisibleRegions = true; 1136 } 1137 1138 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 1139 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 1140 1141 // FIXME: postedRegion should be dirty & bounds 1142 const Layer::State& front(drawingState()); 1143 Region dirtyRegion(Rect(front.active.w, front.active.h)); 1144 1145 // transform the dirty region to window-manager space 1146 outDirtyRegion = (front.transform.transform(dirtyRegion)); 1147 } 1148 return outDirtyRegion; 1149 } 1150 1151 uint32_t Layer::getEffectiveUsage(uint32_t usage) const 1152 { 1153 // TODO: should we do something special if mSecure is set? 1154 if (mProtectedByApp) { 1155 // need a hardware-protected path to external video sink 1156 usage |= GraphicBuffer::USAGE_PROTECTED; 1157 } 1158 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 1159 return usage; 1160 } 1161 1162 void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 1163 uint32_t orientation = 0; 1164 if (!mFlinger->mDebugDisableTransformHint) { 1165 // The transform hint is used to improve performance, but we can 1166 // only have a single transform hint, it cannot 1167 // apply to all displays. 1168 const Transform& planeTransform(hw->getTransform()); 1169 orientation = planeTransform.getOrientation(); 1170 if (orientation & Transform::ROT_INVALID) { 1171 orientation = 0; 1172 } 1173 } 1174 mSurfaceFlingerConsumer->setTransformHint(orientation); 1175 } 1176 1177 // ---------------------------------------------------------------------------- 1178 // debugging 1179 // ---------------------------------------------------------------------------- 1180 1181 void Layer::dump(String8& result, char* buffer, size_t SIZE) const 1182 { 1183 const Layer::State& s(drawingState()); 1184 1185 snprintf(buffer, SIZE, 1186 "+ %s %p (%s)\n", 1187 getTypeId(), this, getName().string()); 1188 result.append(buffer); 1189 1190 s.activeTransparentRegion.dump(result, "transparentRegion"); 1191 visibleRegion.dump(result, "visibleRegion"); 1192 sp<Client> client(mClientRef.promote()); 1193 1194 snprintf(buffer, SIZE, 1195 " " 1196 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), " 1197 "isOpaque=%1d, invalidate=%1d, " 1198 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 1199 " client=%p\n", 1200 s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h, 1201 s.active.crop.left, s.active.crop.top, 1202 s.active.crop.right, s.active.crop.bottom, 1203 isOpaque(), contentDirty, 1204 s.alpha, s.flags, 1205 s.transform[0][0], s.transform[0][1], 1206 s.transform[1][0], s.transform[1][1], 1207 client.get()); 1208 result.append(buffer); 1209 1210 sp<const GraphicBuffer> buf0(mActiveBuffer); 1211 uint32_t w0=0, h0=0, s0=0, f0=0; 1212 if (buf0 != 0) { 1213 w0 = buf0->getWidth(); 1214 h0 = buf0->getHeight(); 1215 s0 = buf0->getStride(); 1216 f0 = buf0->format; 1217 } 1218 snprintf(buffer, SIZE, 1219 " " 1220 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 1221 " queued-frames=%d, mRefreshPending=%d\n", 1222 mFormat, w0, h0, s0,f0, 1223 mQueuedFrames, mRefreshPending); 1224 1225 result.append(buffer); 1226 1227 if (mSurfaceFlingerConsumer != 0) { 1228 mSurfaceFlingerConsumer->dump(result, " ", buffer, SIZE); 1229 } 1230 } 1231 1232 1233 void Layer::shortDump(String8& result, char* scratch, size_t size) const { 1234 Layer::dump(result, scratch, size); 1235 } 1236 1237 void Layer::dumpStats(String8& result, char* buffer, size_t SIZE) const { 1238 mFrameTracker.dump(result); 1239 } 1240 1241 void Layer::clearStats() { 1242 mFrameTracker.clear(); 1243 } 1244 1245 // --------------------------------------------------------------------------- 1246 1247 Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 1248 const sp<Layer>& layer) 1249 : mFlinger(flinger), mLayer(layer) { 1250 } 1251 1252 Layer::LayerCleaner::~LayerCleaner() { 1253 // destroy client resources 1254 mFlinger->onLayerDestroyed(mLayer); 1255 } 1256 1257 // --------------------------------------------------------------------------- 1258 1259 1260 }; // namespace android 1261
