Layer.cpp revision 9e9b0445544f11fdbf21a29601567af2d1819a30
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/NativeHandle.h> 31#include <utils/StopWatch.h> 32#include <utils/Trace.h> 33 34#include <ui/GraphicBuffer.h> 35#include <ui/PixelFormat.h> 36 37#include <gui/BufferItem.h> 38#include <gui/Surface.h> 39 40#include "clz.h" 41#include "Colorizer.h" 42#include "DisplayDevice.h" 43#include "Layer.h" 44#include "MonitoredProducer.h" 45#include "SurfaceFlinger.h" 46 47#include "DisplayHardware/HWComposer.h" 48 49#include "RenderEngine/RenderEngine.h" 50 51#define DEBUG_RESIZE 0 52 53namespace android { 54 55// --------------------------------------------------------------------------- 56 57int32_t Layer::sSequence = 1; 58 59Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client, 60 const String8& name, uint32_t w, uint32_t h, uint32_t flags) 61 : contentDirty(false), 62 sequence(uint32_t(android_atomic_inc(&sSequence))), 63 mFlinger(flinger), 64 mTextureName(-1U), 65 mPremultipliedAlpha(true), 66 mName("unnamed"), 67 mFormat(PIXEL_FORMAT_NONE), 68 mTransactionFlags(0), 69 mQueuedFrames(0), 70 mSidebandStreamChanged(false), 71 mCurrentTransform(0), 72 mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), 73 mCurrentOpacity(true), 74 mRefreshPending(false), 75 mFrameLatencyNeeded(false), 76 mFiltering(false), 77 mNeedsFiltering(false), 78 mMesh(Mesh::TRIANGLE_FAN, 4, 2, 2), 79 mSecure(false), 80 mProtectedByApp(false), 81 mHasSurface(false), 82 mClientRef(client), 83 mPotentialCursor(false) 84{ 85 mCurrentCrop.makeInvalid(); 86 mFlinger->getRenderEngine().genTextures(1, &mTextureName); 87 mTexture.init(Texture::TEXTURE_EXTERNAL, mTextureName); 88 89 uint32_t layerFlags = 0; 90 if (flags & ISurfaceComposerClient::eHidden) 91 layerFlags |= layer_state_t::eLayerHidden; 92 if (flags & ISurfaceComposerClient::eOpaque) 93 layerFlags |= layer_state_t::eLayerOpaque; 94 95 if (flags & ISurfaceComposerClient::eNonPremultiplied) 96 mPremultipliedAlpha = false; 97 98 mName = name; 99 100 mCurrentState.active.w = w; 101 mCurrentState.active.h = h; 102 mCurrentState.active.crop.makeInvalid(); 103 mCurrentState.z = 0; 104 mCurrentState.alpha = 0xFF; 105 mCurrentState.layerStack = 0; 106 mCurrentState.flags = layerFlags; 107 mCurrentState.sequence = 0; 108 mCurrentState.transform.set(0, 0); 109 mCurrentState.requested = mCurrentState.active; 110 111 // drawing state & current state are identical 112 mDrawingState = mCurrentState; 113 114 nsecs_t displayPeriod = 115 flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 116 mFrameTracker.setDisplayRefreshPeriod(displayPeriod); 117} 118 119void Layer::onFirstRef() { 120 // Creates a custom BufferQueue for SurfaceFlingerConsumer to use 121 sp<IGraphicBufferProducer> producer; 122 sp<IGraphicBufferConsumer> consumer; 123 BufferQueue::createBufferQueue(&producer, &consumer); 124 mProducer = new MonitoredProducer(producer, mFlinger); 125 mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName); 126 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 127 mSurfaceFlingerConsumer->setContentsChangedListener(this); 128 mSurfaceFlingerConsumer->setName(mName); 129 130#ifdef TARGET_DISABLE_TRIPLE_BUFFERING 131#warning "disabling triple buffering" 132 mSurfaceFlingerConsumer->setDefaultMaxBufferCount(2); 133#else 134 mSurfaceFlingerConsumer->setDefaultMaxBufferCount(3); 135#endif 136 137 const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); 138 updateTransformHint(hw); 139} 140 141Layer::~Layer() { 142 sp<Client> c(mClientRef.promote()); 143 if (c != 0) { 144 c->detachLayer(this); 145 } 146 mFlinger->deleteTextureAsync(mTextureName); 147 mFrameTracker.logAndResetStats(mName); 148} 149 150// --------------------------------------------------------------------------- 151// callbacks 152// --------------------------------------------------------------------------- 153 154void Layer::onLayerDisplayed(const sp<const DisplayDevice>& /* hw */, 155 HWComposer::HWCLayerInterface* layer) { 156 if (layer) { 157 layer->onDisplayed(); 158 mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFence()); 159 } 160} 161 162void Layer::onFrameAvailable(const BufferItem& item) { 163 // Add this buffer from our internal queue tracker 164 { // Autolock scope 165 Mutex::Autolock lock(mQueueItemLock); 166 mQueueItems.push_back(item); 167 } 168 169 android_atomic_inc(&mQueuedFrames); 170 mFlinger->signalLayerUpdate(); 171} 172 173void Layer::onFrameReplaced(const BufferItem& item) { 174 Mutex::Autolock lock(mQueueItemLock); 175 if (mQueueItems.empty()) { 176 ALOGE("Can't replace a frame on an empty queue"); 177 return; 178 } 179 mQueueItems.editItemAt(0) = item; 180} 181 182void Layer::onSidebandStreamChanged() { 183 if (android_atomic_release_cas(false, true, &mSidebandStreamChanged) == 0) { 184 // mSidebandStreamChanged was false 185 mFlinger->signalLayerUpdate(); 186 } 187} 188 189// called with SurfaceFlinger::mStateLock from the drawing thread after 190// the layer has been remove from the current state list (and just before 191// it's removed from the drawing state list) 192void Layer::onRemoved() { 193 mSurfaceFlingerConsumer->abandon(); 194} 195 196// --------------------------------------------------------------------------- 197// set-up 198// --------------------------------------------------------------------------- 199 200const String8& Layer::getName() const { 201 return mName; 202} 203 204status_t Layer::setBuffers( uint32_t w, uint32_t h, 205 PixelFormat format, uint32_t flags) 206{ 207 uint32_t const maxSurfaceDims = min( 208 mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); 209 210 // never allow a surface larger than what our underlying GL implementation 211 // can handle. 212 if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) { 213 ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); 214 return BAD_VALUE; 215 } 216 217 mFormat = format; 218 219 mPotentialCursor = (flags & ISurfaceComposerClient::eCursorWindow) ? true : false; 220 mSecure = (flags & ISurfaceComposerClient::eSecure) ? true : false; 221 mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; 222 mCurrentOpacity = getOpacityForFormat(format); 223 224 mSurfaceFlingerConsumer->setDefaultBufferSize(w, h); 225 mSurfaceFlingerConsumer->setDefaultBufferFormat(format); 226 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 227 228 return NO_ERROR; 229} 230 231sp<IBinder> Layer::getHandle() { 232 Mutex::Autolock _l(mLock); 233 234 LOG_ALWAYS_FATAL_IF(mHasSurface, 235 "Layer::getHandle() has already been called"); 236 237 mHasSurface = true; 238 239 /* 240 * The layer handle is just a BBinder object passed to the client 241 * (remote process) -- we don't keep any reference on our side such that 242 * the dtor is called when the remote side let go of its reference. 243 * 244 * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for 245 * this layer when the handle is destroyed. 246 */ 247 248 class Handle : public BBinder, public LayerCleaner { 249 wp<const Layer> mOwner; 250 public: 251 Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer) 252 : LayerCleaner(flinger, layer), mOwner(layer) { 253 } 254 }; 255 256 return new Handle(mFlinger, this); 257} 258 259sp<IGraphicBufferProducer> Layer::getProducer() const { 260 return mProducer; 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 284static Rect reduce(const Rect& win, const Region& exclude) { 285 if (CC_LIKELY(exclude.isEmpty())) { 286 return win; 287 } 288 if (exclude.isRect()) { 289 return win.reduce(exclude.getBounds()); 290 } 291 return Region(win).subtract(exclude).getBounds(); 292} 293 294Rect Layer::computeBounds() const { 295 const Layer::State& s(getDrawingState()); 296 return computeBounds(s.activeTransparentRegion); 297} 298 299Rect Layer::computeBounds(const Region& activeTransparentRegion) const { 300 const Layer::State& s(getDrawingState()); 301 Rect win(s.active.w, s.active.h); 302 if (!s.active.crop.isEmpty()) { 303 win.intersect(s.active.crop, &win); 304 } 305 // subtract the transparent region and snap to the bounds 306 return reduce(win, activeTransparentRegion); 307} 308 309FloatRect Layer::computeCrop(const sp<const DisplayDevice>& hw) const { 310 // the content crop is the area of the content that gets scaled to the 311 // layer's size. 312 FloatRect crop(getContentCrop()); 313 314 // the active.crop is the area of the window that gets cropped, but not 315 // scaled in any ways. 316 const State& s(getDrawingState()); 317 318 // apply the projection's clipping to the window crop in 319 // layerstack space, and convert-back to layer space. 320 // if there are no window scaling involved, this operation will map to full 321 // pixels in the buffer. 322 // FIXME: the 3 lines below can produce slightly incorrect clipping when we have 323 // a viewport clipping and a window transform. we should use floating point to fix this. 324 325 Rect activeCrop(s.active.w, s.active.h); 326 if (!s.active.crop.isEmpty()) { 327 activeCrop = s.active.crop; 328 } 329 330 activeCrop = s.transform.transform(activeCrop); 331 activeCrop.intersect(hw->getViewport(), &activeCrop); 332 activeCrop = s.transform.inverse().transform(activeCrop); 333 334 // This needs to be here as transform.transform(Rect) computes the 335 // transformed rect and then takes the bounding box of the result before 336 // returning. This means 337 // transform.inverse().transform(transform.transform(Rect)) != Rect 338 // in which case we need to make sure the final rect is clipped to the 339 // display bounds. 340 activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop); 341 342 // subtract the transparent region and snap to the bounds 343 activeCrop = reduce(activeCrop, s.activeTransparentRegion); 344 345 if (!activeCrop.isEmpty()) { 346 // Transform the window crop to match the buffer coordinate system, 347 // which means using the inverse of the current transform set on the 348 // SurfaceFlingerConsumer. 349 uint32_t invTransform = mCurrentTransform; 350 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { 351 /* 352 * the code below applies the display's inverse transform to the buffer 353 */ 354 uint32_t invTransformOrient = hw->getOrientationTransform(); 355 // calculate the inverse transform 356 if (invTransformOrient & NATIVE_WINDOW_TRANSFORM_ROT_90) { 357 invTransformOrient ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 358 NATIVE_WINDOW_TRANSFORM_FLIP_H; 359 // If the transform has been rotated the axis of flip has been swapped 360 // so we need to swap which flip operations we are performing 361 bool is_h_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; 362 bool is_v_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; 363 if (is_h_flipped != is_v_flipped) { 364 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 365 NATIVE_WINDOW_TRANSFORM_FLIP_H; 366 } 367 } 368 // and apply to the current transform 369 invTransform = (Transform(invTransform) * Transform(invTransformOrient)).getOrientation(); 370 } 371 372 int winWidth = s.active.w; 373 int winHeight = s.active.h; 374 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 375 // If the activeCrop has been rotate the ends are rotated but not 376 // the space itself so when transforming ends back we can't rely on 377 // a modification of the axes of rotation. To account for this we 378 // need to reorient the inverse rotation in terms of the current 379 // axes of rotation. 380 bool is_h_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; 381 bool is_v_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; 382 if (is_h_flipped == is_v_flipped) { 383 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 384 NATIVE_WINDOW_TRANSFORM_FLIP_H; 385 } 386 winWidth = s.active.h; 387 winHeight = s.active.w; 388 } 389 const Rect winCrop = activeCrop.transform( 390 invTransform, s.active.w, s.active.h); 391 392 // below, crop is intersected with winCrop expressed in crop's coordinate space 393 float xScale = crop.getWidth() / float(winWidth); 394 float yScale = crop.getHeight() / float(winHeight); 395 396 float insetL = winCrop.left * xScale; 397 float insetT = winCrop.top * yScale; 398 float insetR = (winWidth - winCrop.right ) * xScale; 399 float insetB = (winHeight - winCrop.bottom) * yScale; 400 401 crop.left += insetL; 402 crop.top += insetT; 403 crop.right -= insetR; 404 crop.bottom -= insetB; 405 } 406 return crop; 407} 408 409void Layer::setGeometry( 410 const sp<const DisplayDevice>& hw, 411 HWComposer::HWCLayerInterface& layer) 412{ 413 layer.setDefaultState(); 414 415 // enable this layer 416 layer.setSkip(false); 417 418 if (isSecure() && !hw->isSecure()) { 419 layer.setSkip(true); 420 } 421 422 // this gives us only the "orientation" component of the transform 423 const State& s(getDrawingState()); 424 if (!isOpaque(s) || s.alpha != 0xFF) { 425 layer.setBlending(mPremultipliedAlpha ? 426 HWC_BLENDING_PREMULT : 427 HWC_BLENDING_COVERAGE); 428 } 429 430 // apply the layer's transform, followed by the display's global transform 431 // here we're guaranteed that the layer's transform preserves rects 432 Region activeTransparentRegion(s.activeTransparentRegion); 433 if (!s.active.crop.isEmpty()) { 434 Rect activeCrop(s.active.crop); 435 activeCrop = s.transform.transform(activeCrop); 436 activeCrop.intersect(hw->getViewport(), &activeCrop); 437 activeCrop = s.transform.inverse().transform(activeCrop); 438 // This needs to be here as transform.transform(Rect) computes the 439 // transformed rect and then takes the bounding box of the result before 440 // returning. This means 441 // transform.inverse().transform(transform.transform(Rect)) != Rect 442 // in which case we need to make sure the final rect is clipped to the 443 // display bounds. 444 activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop); 445 // mark regions outside the crop as transparent 446 activeTransparentRegion.orSelf(Rect(0, 0, s.active.w, activeCrop.top)); 447 activeTransparentRegion.orSelf(Rect(0, activeCrop.bottom, 448 s.active.w, s.active.h)); 449 activeTransparentRegion.orSelf(Rect(0, activeCrop.top, 450 activeCrop.left, activeCrop.bottom)); 451 activeTransparentRegion.orSelf(Rect(activeCrop.right, activeCrop.top, 452 s.active.w, activeCrop.bottom)); 453 } 454 Rect frame(s.transform.transform(computeBounds(activeTransparentRegion))); 455 frame.intersect(hw->getViewport(), &frame); 456 const Transform& tr(hw->getTransform()); 457 layer.setFrame(tr.transform(frame)); 458 layer.setCrop(computeCrop(hw)); 459 layer.setPlaneAlpha(s.alpha); 460 461 /* 462 * Transformations are applied in this order: 463 * 1) buffer orientation/flip/mirror 464 * 2) state transformation (window manager) 465 * 3) layer orientation (screen orientation) 466 * (NOTE: the matrices are multiplied in reverse order) 467 */ 468 469 const Transform bufferOrientation(mCurrentTransform); 470 Transform transform(tr * s.transform * bufferOrientation); 471 472 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { 473 /* 474 * the code below applies the display's inverse transform to the buffer 475 */ 476 uint32_t invTransform = hw->getOrientationTransform(); 477 uint32_t t_orientation = transform.getOrientation(); 478 // calculate the inverse transform 479 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 480 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 481 NATIVE_WINDOW_TRANSFORM_FLIP_H; 482 // If the transform has been rotated the axis of flip has been swapped 483 // so we need to swap which flip operations we are performing 484 bool is_h_flipped = (t_orientation & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; 485 bool is_v_flipped = (t_orientation & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; 486 if (is_h_flipped != is_v_flipped) { 487 t_orientation ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 488 NATIVE_WINDOW_TRANSFORM_FLIP_H; 489 } 490 } 491 // and apply to the current transform 492 transform = Transform(t_orientation) * Transform(invTransform); 493 } 494 495 // this gives us only the "orientation" component of the transform 496 const uint32_t orientation = transform.getOrientation(); 497 if (orientation & Transform::ROT_INVALID) { 498 // we can only handle simple transformation 499 layer.setSkip(true); 500 } else { 501 layer.setTransform(orientation); 502 } 503} 504 505void Layer::setPerFrameData(const sp<const DisplayDevice>& hw, 506 HWComposer::HWCLayerInterface& layer) { 507 // we have to set the visible region on every frame because 508 // we currently free it during onLayerDisplayed(), which is called 509 // after HWComposer::commit() -- every frame. 510 // Apply this display's projection's viewport to the visible region 511 // before giving it to the HWC HAL. 512 const Transform& tr = hw->getTransform(); 513 Region visible = tr.transform(visibleRegion.intersect(hw->getViewport())); 514 layer.setVisibleRegionScreen(visible); 515 516 // Pass full-surface damage down untouched 517 if (surfaceDamageRegion.isRect() && 518 surfaceDamageRegion.getBounds() == Rect::INVALID_RECT) { 519 layer.setSurfaceDamage(surfaceDamageRegion); 520 } else { 521 Region surfaceDamage = 522 tr.transform(surfaceDamageRegion.intersect(hw->getViewport())); 523 layer.setSurfaceDamage(surfaceDamage); 524 } 525 526 if (mSidebandStream.get()) { 527 layer.setSidebandStream(mSidebandStream); 528 } else { 529 // NOTE: buffer can be NULL if the client never drew into this 530 // layer yet, or if we ran out of memory 531 layer.setBuffer(mActiveBuffer); 532 } 533} 534 535void Layer::setAcquireFence(const sp<const DisplayDevice>& /* hw */, 536 HWComposer::HWCLayerInterface& layer) { 537 int fenceFd = -1; 538 539 // TODO: there is a possible optimization here: we only need to set the 540 // acquire fence the first time a new buffer is acquired on EACH display. 541 542 if (layer.getCompositionType() == HWC_OVERLAY || layer.getCompositionType() == HWC_CURSOR_OVERLAY) { 543 sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence(); 544 if (fence->isValid()) { 545 fenceFd = fence->dup(); 546 if (fenceFd == -1) { 547 ALOGW("failed to dup layer fence, skipping sync: %d", errno); 548 } 549 } 550 } 551 layer.setAcquireFenceFd(fenceFd); 552} 553 554Rect Layer::getPosition( 555 const sp<const DisplayDevice>& hw) 556{ 557 // this gives us only the "orientation" component of the transform 558 const State& s(getCurrentState()); 559 560 // apply the layer's transform, followed by the display's global transform 561 // here we're guaranteed that the layer's transform preserves rects 562 Rect win(s.active.w, s.active.h); 563 if (!s.active.crop.isEmpty()) { 564 win.intersect(s.active.crop, &win); 565 } 566 // subtract the transparent region and snap to the bounds 567 Rect bounds = reduce(win, s.activeTransparentRegion); 568 Rect frame(s.transform.transform(bounds)); 569 frame.intersect(hw->getViewport(), &frame); 570 const Transform& tr(hw->getTransform()); 571 return Rect(tr.transform(frame)); 572} 573 574// --------------------------------------------------------------------------- 575// drawing... 576// --------------------------------------------------------------------------- 577 578void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const { 579 onDraw(hw, clip, false); 580} 581 582void Layer::draw(const sp<const DisplayDevice>& hw, 583 bool useIdentityTransform) const { 584 onDraw(hw, Region(hw->bounds()), useIdentityTransform); 585} 586 587void Layer::draw(const sp<const DisplayDevice>& hw) const { 588 onDraw(hw, Region(hw->bounds()), false); 589} 590 591void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip, 592 bool useIdentityTransform) const 593{ 594 ATRACE_CALL(); 595 596 if (CC_UNLIKELY(mActiveBuffer == 0)) { 597 // the texture has not been created yet, this Layer has 598 // in fact never been drawn into. This happens frequently with 599 // SurfaceView because the WindowManager can't know when the client 600 // has drawn the first time. 601 602 // If there is nothing under us, we paint the screen in black, otherwise 603 // we just skip this update. 604 605 // figure out if there is something below us 606 Region under; 607 const SurfaceFlinger::LayerVector& drawingLayers( 608 mFlinger->mDrawingState.layersSortedByZ); 609 const size_t count = drawingLayers.size(); 610 for (size_t i=0 ; i<count ; ++i) { 611 const sp<Layer>& layer(drawingLayers[i]); 612 if (layer.get() == static_cast<Layer const*>(this)) 613 break; 614 under.orSelf( hw->getTransform().transform(layer->visibleRegion) ); 615 } 616 // if not everything below us is covered, we plug the holes! 617 Region holes(clip.subtract(under)); 618 if (!holes.isEmpty()) { 619 clearWithOpenGL(hw, holes, 0, 0, 0, 1); 620 } 621 return; 622 } 623 624 // Bind the current buffer to the GL texture, and wait for it to be 625 // ready for us to draw into. 626 status_t err = mSurfaceFlingerConsumer->bindTextureImage(); 627 if (err != NO_ERROR) { 628 ALOGW("onDraw: bindTextureImage failed (err=%d)", err); 629 // Go ahead and draw the buffer anyway; no matter what we do the screen 630 // is probably going to have something visibly wrong. 631 } 632 633 bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure()); 634 635 RenderEngine& engine(mFlinger->getRenderEngine()); 636 637 if (!blackOutLayer) { 638 // TODO: we could be more subtle with isFixedSize() 639 const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize(); 640 641 // Query the texture matrix given our current filtering mode. 642 float textureMatrix[16]; 643 mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering); 644 mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix); 645 646 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { 647 648 /* 649 * the code below applies the display's inverse transform to the texture transform 650 */ 651 652 // create a 4x4 transform matrix from the display transform flags 653 const mat4 flipH(-1,0,0,0, 0,1,0,0, 0,0,1,0, 1,0,0,1); 654 const mat4 flipV( 1,0,0,0, 0,-1,0,0, 0,0,1,0, 0,1,0,1); 655 const mat4 rot90( 0,1,0,0, -1,0,0,0, 0,0,1,0, 1,0,0,1); 656 657 mat4 tr; 658 uint32_t transform = hw->getOrientationTransform(); 659 if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90) 660 tr = tr * rot90; 661 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H) 662 tr = tr * flipH; 663 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V) 664 tr = tr * flipV; 665 666 // calculate the inverse 667 tr = inverse(tr); 668 669 // and finally apply it to the original texture matrix 670 const mat4 texTransform(mat4(static_cast<const float*>(textureMatrix)) * tr); 671 memcpy(textureMatrix, texTransform.asArray(), sizeof(textureMatrix)); 672 } 673 674 // Set things up for texturing. 675 mTexture.setDimensions(mActiveBuffer->getWidth(), mActiveBuffer->getHeight()); 676 mTexture.setFiltering(useFiltering); 677 mTexture.setMatrix(textureMatrix); 678 679 engine.setupLayerTexturing(mTexture); 680 } else { 681 engine.setupLayerBlackedOut(); 682 } 683 drawWithOpenGL(hw, clip, useIdentityTransform); 684 engine.disableTexturing(); 685} 686 687 688void Layer::clearWithOpenGL(const sp<const DisplayDevice>& hw, 689 const Region& /* clip */, float red, float green, float blue, 690 float alpha) const 691{ 692 RenderEngine& engine(mFlinger->getRenderEngine()); 693 computeGeometry(hw, mMesh, false); 694 engine.setupFillWithColor(red, green, blue, alpha); 695 engine.drawMesh(mMesh); 696} 697 698void Layer::clearWithOpenGL( 699 const sp<const DisplayDevice>& hw, const Region& clip) const { 700 clearWithOpenGL(hw, clip, 0,0,0,0); 701} 702 703void Layer::drawWithOpenGL(const sp<const DisplayDevice>& hw, 704 const Region& /* clip */, bool useIdentityTransform) const { 705 const State& s(getDrawingState()); 706 707 computeGeometry(hw, mMesh, useIdentityTransform); 708 709 /* 710 * NOTE: the way we compute the texture coordinates here produces 711 * different results than when we take the HWC path -- in the later case 712 * the "source crop" is rounded to texel boundaries. 713 * This can produce significantly different results when the texture 714 * is scaled by a large amount. 715 * 716 * The GL code below is more logical (imho), and the difference with 717 * HWC is due to a limitation of the HWC API to integers -- a question 718 * is suspend is whether we should ignore this problem or revert to 719 * GL composition when a buffer scaling is applied (maybe with some 720 * minimal value)? Or, we could make GL behave like HWC -- but this feel 721 * like more of a hack. 722 */ 723 const Rect win(computeBounds()); 724 725 float left = float(win.left) / float(s.active.w); 726 float top = float(win.top) / float(s.active.h); 727 float right = float(win.right) / float(s.active.w); 728 float bottom = float(win.bottom) / float(s.active.h); 729 730 // TODO: we probably want to generate the texture coords with the mesh 731 // here we assume that we only have 4 vertices 732 Mesh::VertexArray<vec2> texCoords(mMesh.getTexCoordArray<vec2>()); 733 texCoords[0] = vec2(left, 1.0f - top); 734 texCoords[1] = vec2(left, 1.0f - bottom); 735 texCoords[2] = vec2(right, 1.0f - bottom); 736 texCoords[3] = vec2(right, 1.0f - top); 737 738 RenderEngine& engine(mFlinger->getRenderEngine()); 739 engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), s.alpha); 740 engine.drawMesh(mMesh); 741 engine.disableBlending(); 742} 743 744uint32_t Layer::getProducerStickyTransform() const { 745 int producerStickyTransform = 0; 746 int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform); 747 if (ret != OK) { 748 ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__, 749 strerror(-ret), ret); 750 return 0; 751 } 752 return static_cast<uint32_t>(producerStickyTransform); 753} 754 755void Layer::setFiltering(bool filtering) { 756 mFiltering = filtering; 757} 758 759bool Layer::getFiltering() const { 760 return mFiltering; 761} 762 763// As documented in libhardware header, formats in the range 764// 0x100 - 0x1FF are specific to the HAL implementation, and 765// are known to have no alpha channel 766// TODO: move definition for device-specific range into 767// hardware.h, instead of using hard-coded values here. 768#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) 769 770bool Layer::getOpacityForFormat(uint32_t format) { 771 if (HARDWARE_IS_DEVICE_FORMAT(format)) { 772 return true; 773 } 774 switch (format) { 775 case HAL_PIXEL_FORMAT_RGBA_8888: 776 case HAL_PIXEL_FORMAT_BGRA_8888: 777 return false; 778 } 779 // in all other case, we have no blending (also for unknown formats) 780 return true; 781} 782 783// ---------------------------------------------------------------------------- 784// local state 785// ---------------------------------------------------------------------------- 786 787void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh, 788 bool useIdentityTransform) const 789{ 790 const Layer::State& s(getDrawingState()); 791 const Transform tr(useIdentityTransform ? 792 hw->getTransform() : hw->getTransform() * s.transform); 793 const uint32_t hw_h = hw->getHeight(); 794 Rect win(s.active.w, s.active.h); 795 if (!s.active.crop.isEmpty()) { 796 win.intersect(s.active.crop, &win); 797 } 798 // subtract the transparent region and snap to the bounds 799 win = reduce(win, s.activeTransparentRegion); 800 801 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>()); 802 position[0] = tr.transform(win.left, win.top); 803 position[1] = tr.transform(win.left, win.bottom); 804 position[2] = tr.transform(win.right, win.bottom); 805 position[3] = tr.transform(win.right, win.top); 806 for (size_t i=0 ; i<4 ; i++) { 807 position[i].y = hw_h - position[i].y; 808 } 809} 810 811bool Layer::isOpaque(const Layer::State& s) const 812{ 813 // if we don't have a buffer yet, we're translucent regardless of the 814 // layer's opaque flag. 815 if (mActiveBuffer == 0) { 816 return false; 817 } 818 819 // if the layer has the opaque flag, then we're always opaque, 820 // otherwise we use the current buffer's format. 821 return ((s.flags & layer_state_t::eLayerOpaque) != 0) || mCurrentOpacity; 822} 823 824bool Layer::isProtected() const 825{ 826 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 827 return (activeBuffer != 0) && 828 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 829} 830 831bool Layer::isFixedSize() const { 832 return mCurrentScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 833} 834 835bool Layer::isCropped() const { 836 return !mCurrentCrop.isEmpty(); 837} 838 839bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const { 840 return mNeedsFiltering || hw->needsFiltering(); 841} 842 843void Layer::setVisibleRegion(const Region& visibleRegion) { 844 // always called from main thread 845 this->visibleRegion = visibleRegion; 846} 847 848void Layer::setCoveredRegion(const Region& coveredRegion) { 849 // always called from main thread 850 this->coveredRegion = coveredRegion; 851} 852 853void Layer::setVisibleNonTransparentRegion(const Region& 854 setVisibleNonTransparentRegion) { 855 // always called from main thread 856 this->visibleNonTransparentRegion = setVisibleNonTransparentRegion; 857} 858 859// ---------------------------------------------------------------------------- 860// transaction 861// ---------------------------------------------------------------------------- 862 863uint32_t Layer::doTransaction(uint32_t flags) { 864 ATRACE_CALL(); 865 866 const Layer::State& s(getDrawingState()); 867 const Layer::State& c(getCurrentState()); 868 869 const bool sizeChanged = (c.requested.w != s.requested.w) || 870 (c.requested.h != s.requested.h); 871 872 if (sizeChanged) { 873 // the size changed, we need to ask our client to request a new buffer 874 ALOGD_IF(DEBUG_RESIZE, 875 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 876 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 877 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n" 878 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 879 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 880 this, getName().string(), mCurrentTransform, mCurrentScalingMode, 881 c.active.w, c.active.h, 882 c.active.crop.left, 883 c.active.crop.top, 884 c.active.crop.right, 885 c.active.crop.bottom, 886 c.active.crop.getWidth(), 887 c.active.crop.getHeight(), 888 c.requested.w, c.requested.h, 889 c.requested.crop.left, 890 c.requested.crop.top, 891 c.requested.crop.right, 892 c.requested.crop.bottom, 893 c.requested.crop.getWidth(), 894 c.requested.crop.getHeight(), 895 s.active.w, s.active.h, 896 s.active.crop.left, 897 s.active.crop.top, 898 s.active.crop.right, 899 s.active.crop.bottom, 900 s.active.crop.getWidth(), 901 s.active.crop.getHeight(), 902 s.requested.w, s.requested.h, 903 s.requested.crop.left, 904 s.requested.crop.top, 905 s.requested.crop.right, 906 s.requested.crop.bottom, 907 s.requested.crop.getWidth(), 908 s.requested.crop.getHeight()); 909 910 // record the new size, form this point on, when the client request 911 // a buffer, it'll get the new size. 912 mSurfaceFlingerConsumer->setDefaultBufferSize( 913 c.requested.w, c.requested.h); 914 } 915 916 if (!isFixedSize()) { 917 918 const bool resizePending = (c.requested.w != c.active.w) || 919 (c.requested.h != c.active.h); 920 921 if (resizePending && mSidebandStream == NULL) { 922 // don't let Layer::doTransaction update the drawing state 923 // if we have a pending resize, unless we are in fixed-size mode. 924 // the drawing state will be updated only once we receive a buffer 925 // with the correct size. 926 // 927 // in particular, we want to make sure the clip (which is part 928 // of the geometry state) is latched together with the size but is 929 // latched immediately when no resizing is involved. 930 // 931 // If a sideband stream is attached, however, we want to skip this 932 // optimization so that transactions aren't missed when a buffer 933 // never arrives 934 935 flags |= eDontUpdateGeometryState; 936 } 937 } 938 939 // always set active to requested, unless we're asked not to 940 // this is used by Layer, which special cases resizes. 941 if (flags & eDontUpdateGeometryState) { 942 } else { 943 Layer::State& editCurrentState(getCurrentState()); 944 editCurrentState.active = c.requested; 945 } 946 947 if (s.active != c.active) { 948 // invalidate and recompute the visible regions if needed 949 flags |= Layer::eVisibleRegion; 950 } 951 952 if (c.sequence != s.sequence) { 953 // invalidate and recompute the visible regions if needed 954 flags |= eVisibleRegion; 955 this->contentDirty = true; 956 957 // we may use linear filtering, if the matrix scales us 958 const uint8_t type = c.transform.getType(); 959 mNeedsFiltering = (!c.transform.preserveRects() || 960 (type >= Transform::SCALE)); 961 } 962 963 // Commit the transaction 964 commitTransaction(); 965 return flags; 966} 967 968void Layer::commitTransaction() { 969 mDrawingState = mCurrentState; 970} 971 972uint32_t Layer::getTransactionFlags(uint32_t flags) { 973 return android_atomic_and(~flags, &mTransactionFlags) & flags; 974} 975 976uint32_t Layer::setTransactionFlags(uint32_t flags) { 977 return android_atomic_or(flags, &mTransactionFlags); 978} 979 980bool Layer::setPosition(float x, float y) { 981 if (mCurrentState.transform.tx() == x && mCurrentState.transform.ty() == y) 982 return false; 983 mCurrentState.sequence++; 984 mCurrentState.transform.set(x, y); 985 setTransactionFlags(eTransactionNeeded); 986 return true; 987} 988bool Layer::setLayer(uint32_t z) { 989 if (mCurrentState.z == z) 990 return false; 991 mCurrentState.sequence++; 992 mCurrentState.z = z; 993 setTransactionFlags(eTransactionNeeded); 994 return true; 995} 996bool Layer::setSize(uint32_t w, uint32_t h) { 997 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 998 return false; 999 mCurrentState.requested.w = w; 1000 mCurrentState.requested.h = h; 1001 setTransactionFlags(eTransactionNeeded); 1002 return true; 1003} 1004bool Layer::setAlpha(uint8_t alpha) { 1005 if (mCurrentState.alpha == alpha) 1006 return false; 1007 mCurrentState.sequence++; 1008 mCurrentState.alpha = alpha; 1009 setTransactionFlags(eTransactionNeeded); 1010 return true; 1011} 1012bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 1013 mCurrentState.sequence++; 1014 mCurrentState.transform.set( 1015 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); 1016 setTransactionFlags(eTransactionNeeded); 1017 return true; 1018} 1019bool Layer::setTransparentRegionHint(const Region& transparent) { 1020 mCurrentState.requestedTransparentRegion = transparent; 1021 setTransactionFlags(eTransactionNeeded); 1022 return true; 1023} 1024bool Layer::setFlags(uint8_t flags, uint8_t mask) { 1025 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 1026 if (mCurrentState.flags == newFlags) 1027 return false; 1028 mCurrentState.sequence++; 1029 mCurrentState.flags = newFlags; 1030 setTransactionFlags(eTransactionNeeded); 1031 return true; 1032} 1033bool Layer::setCrop(const Rect& crop) { 1034 if (mCurrentState.requested.crop == crop) 1035 return false; 1036 mCurrentState.sequence++; 1037 mCurrentState.requested.crop = crop; 1038 setTransactionFlags(eTransactionNeeded); 1039 return true; 1040} 1041 1042bool Layer::setLayerStack(uint32_t layerStack) { 1043 if (mCurrentState.layerStack == layerStack) 1044 return false; 1045 mCurrentState.sequence++; 1046 mCurrentState.layerStack = layerStack; 1047 setTransactionFlags(eTransactionNeeded); 1048 return true; 1049} 1050 1051void Layer::useSurfaceDamage() { 1052 if (mFlinger->mForceFullDamage) { 1053 surfaceDamageRegion = Region::INVALID_REGION; 1054 } else { 1055 surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage(); 1056 } 1057} 1058 1059void Layer::useEmptyDamage() { 1060 surfaceDamageRegion.clear(); 1061} 1062 1063// ---------------------------------------------------------------------------- 1064// pageflip handling... 1065// ---------------------------------------------------------------------------- 1066 1067bool Layer::shouldPresentNow(const DispSync& dispSync) const { 1068 Mutex::Autolock lock(mQueueItemLock); 1069 nsecs_t expectedPresent = 1070 mSurfaceFlingerConsumer->computeExpectedPresent(dispSync); 1071 return mQueueItems.empty() ? 1072 false : mQueueItems[0].mTimestamp < expectedPresent; 1073} 1074 1075bool Layer::onPreComposition() { 1076 mRefreshPending = false; 1077 return mQueuedFrames > 0 || mSidebandStreamChanged; 1078} 1079 1080void Layer::onPostComposition() { 1081 if (mFrameLatencyNeeded) { 1082 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 1083 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 1084 1085 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 1086 if (frameReadyFence->isValid()) { 1087 mFrameTracker.setFrameReadyFence(frameReadyFence); 1088 } else { 1089 // There was no fence for this frame, so assume that it was ready 1090 // to be presented at the desired present time. 1091 mFrameTracker.setFrameReadyTime(desiredPresentTime); 1092 } 1093 1094 const HWComposer& hwc = mFlinger->getHwComposer(); 1095 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 1096 if (presentFence->isValid()) { 1097 mFrameTracker.setActualPresentFence(presentFence); 1098 } else { 1099 // The HWC doesn't support present fences, so use the refresh 1100 // timestamp instead. 1101 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 1102 mFrameTracker.setActualPresentTime(presentTime); 1103 } 1104 1105 mFrameTracker.advanceFrame(); 1106 mFrameLatencyNeeded = false; 1107 } 1108} 1109 1110bool Layer::isVisible() const { 1111 const Layer::State& s(mDrawingState); 1112 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha 1113 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1114} 1115 1116Region Layer::latchBuffer(bool& recomputeVisibleRegions) 1117{ 1118 ATRACE_CALL(); 1119 1120 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { 1121 // mSidebandStreamChanged was true 1122 mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream(); 1123 recomputeVisibleRegions = true; 1124 1125 const State& s(getDrawingState()); 1126 return s.transform.transform(Region(Rect(s.active.w, s.active.h))); 1127 } 1128 1129 Region outDirtyRegion; 1130 if (mQueuedFrames > 0) { 1131 1132 // if we've already called updateTexImage() without going through 1133 // a composition step, we have to skip this layer at this point 1134 // because we cannot call updateTeximage() without a corresponding 1135 // compositionComplete() call. 1136 // we'll trigger an update in onPreComposition(). 1137 if (mRefreshPending) { 1138 return outDirtyRegion; 1139 } 1140 1141 // Capture the old state of the layer for comparisons later 1142 const State& s(getDrawingState()); 1143 const bool oldOpacity = isOpaque(s); 1144 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 1145 1146 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 1147 Layer::State& front; 1148 Layer::State& current; 1149 bool& recomputeVisibleRegions; 1150 bool stickyTransformSet; 1151 Reject(Layer::State& front, Layer::State& current, 1152 bool& recomputeVisibleRegions, bool stickySet) 1153 : front(front), current(current), 1154 recomputeVisibleRegions(recomputeVisibleRegions), 1155 stickyTransformSet(stickySet) { 1156 } 1157 1158 virtual bool reject(const sp<GraphicBuffer>& buf, 1159 const BufferItem& item) { 1160 if (buf == NULL) { 1161 return false; 1162 } 1163 1164 uint32_t bufWidth = buf->getWidth(); 1165 uint32_t bufHeight = buf->getHeight(); 1166 1167 // check that we received a buffer of the right size 1168 // (Take the buffer's orientation into account) 1169 if (item.mTransform & Transform::ROT_90) { 1170 swap(bufWidth, bufHeight); 1171 } 1172 1173 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1174 if (front.active != front.requested) { 1175 1176 if (isFixedSize || 1177 (bufWidth == front.requested.w && 1178 bufHeight == front.requested.h)) 1179 { 1180 // Here we pretend the transaction happened by updating the 1181 // current and drawing states. Drawing state is only accessed 1182 // in this thread, no need to have it locked 1183 front.active = front.requested; 1184 1185 // We also need to update the current state so that 1186 // we don't end-up overwriting the drawing state with 1187 // this stale current state during the next transaction 1188 // 1189 // NOTE: We don't need to hold the transaction lock here 1190 // because State::active is only accessed from this thread. 1191 current.active = front.active; 1192 1193 // recompute visible region 1194 recomputeVisibleRegions = true; 1195 } 1196 1197 ALOGD_IF(DEBUG_RESIZE, 1198 "latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 1199 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1200 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 1201 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 1202 front.active.w, front.active.h, 1203 front.active.crop.left, 1204 front.active.crop.top, 1205 front.active.crop.right, 1206 front.active.crop.bottom, 1207 front.active.crop.getWidth(), 1208 front.active.crop.getHeight(), 1209 front.requested.w, front.requested.h, 1210 front.requested.crop.left, 1211 front.requested.crop.top, 1212 front.requested.crop.right, 1213 front.requested.crop.bottom, 1214 front.requested.crop.getWidth(), 1215 front.requested.crop.getHeight()); 1216 } 1217 1218 if (!isFixedSize && !stickyTransformSet) { 1219 if (front.active.w != bufWidth || 1220 front.active.h != bufHeight) { 1221 // reject this buffer 1222 ALOGE("rejecting buffer: bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}", 1223 bufWidth, bufHeight, front.active.w, front.active.h); 1224 return true; 1225 } 1226 } 1227 1228 // if the transparent region has changed (this test is 1229 // conservative, but that's fine, worst case we're doing 1230 // a bit of extra work), we latch the new one and we 1231 // trigger a visible-region recompute. 1232 if (!front.activeTransparentRegion.isTriviallyEqual( 1233 front.requestedTransparentRegion)) { 1234 front.activeTransparentRegion = front.requestedTransparentRegion; 1235 1236 // We also need to update the current state so that 1237 // we don't end-up overwriting the drawing state with 1238 // this stale current state during the next transaction 1239 // 1240 // NOTE: We don't need to hold the transaction lock here 1241 // because State::active is only accessed from this thread. 1242 current.activeTransparentRegion = front.activeTransparentRegion; 1243 1244 // recompute visible region 1245 recomputeVisibleRegions = true; 1246 } 1247 1248 return false; 1249 } 1250 }; 1251 1252 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 1253 getProducerStickyTransform() != 0); 1254 1255 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, 1256 mFlinger->mPrimaryDispSync); 1257 if (updateResult == BufferQueue::PRESENT_LATER) { 1258 // Producer doesn't want buffer to be displayed yet. Signal a 1259 // layer update so we check again at the next opportunity. 1260 mFlinger->signalLayerUpdate(); 1261 return outDirtyRegion; 1262 } 1263 1264 // Remove this buffer from our internal queue tracker 1265 { // Autolock scope 1266 Mutex::Autolock lock(mQueueItemLock); 1267 mQueueItems.removeAt(0); 1268 } 1269 1270 // Decrement the queued-frames count. Signal another event if we 1271 // have more frames pending. 1272 if (android_atomic_dec(&mQueuedFrames) > 1) { 1273 mFlinger->signalLayerUpdate(); 1274 } 1275 1276 if (updateResult != NO_ERROR) { 1277 // something happened! 1278 recomputeVisibleRegions = true; 1279 return outDirtyRegion; 1280 } 1281 1282 // update the active buffer 1283 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 1284 if (mActiveBuffer == NULL) { 1285 // this can only happen if the very first buffer was rejected. 1286 return outDirtyRegion; 1287 } 1288 1289 mRefreshPending = true; 1290 mFrameLatencyNeeded = true; 1291 if (oldActiveBuffer == NULL) { 1292 // the first time we receive a buffer, we need to trigger a 1293 // geometry invalidation. 1294 recomputeVisibleRegions = true; 1295 } 1296 1297 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 1298 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 1299 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 1300 if ((crop != mCurrentCrop) || 1301 (transform != mCurrentTransform) || 1302 (scalingMode != mCurrentScalingMode)) 1303 { 1304 mCurrentCrop = crop; 1305 mCurrentTransform = transform; 1306 mCurrentScalingMode = scalingMode; 1307 recomputeVisibleRegions = true; 1308 } 1309 1310 if (oldActiveBuffer != NULL) { 1311 uint32_t bufWidth = mActiveBuffer->getWidth(); 1312 uint32_t bufHeight = mActiveBuffer->getHeight(); 1313 if (bufWidth != uint32_t(oldActiveBuffer->width) || 1314 bufHeight != uint32_t(oldActiveBuffer->height)) { 1315 recomputeVisibleRegions = true; 1316 } 1317 } 1318 1319 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 1320 if (oldOpacity != isOpaque(s)) { 1321 recomputeVisibleRegions = true; 1322 } 1323 1324 // FIXME: postedRegion should be dirty & bounds 1325 Region dirtyRegion(Rect(s.active.w, s.active.h)); 1326 1327 // transform the dirty region to window-manager space 1328 outDirtyRegion = (s.transform.transform(dirtyRegion)); 1329 } 1330 return outDirtyRegion; 1331} 1332 1333uint32_t Layer::getEffectiveUsage(uint32_t usage) const 1334{ 1335 // TODO: should we do something special if mSecure is set? 1336 if (mProtectedByApp) { 1337 // need a hardware-protected path to external video sink 1338 usage |= GraphicBuffer::USAGE_PROTECTED; 1339 } 1340 if (mPotentialCursor) { 1341 usage |= GraphicBuffer::USAGE_CURSOR; 1342 } 1343 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 1344 return usage; 1345} 1346 1347void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 1348 uint32_t orientation = 0; 1349 if (!mFlinger->mDebugDisableTransformHint) { 1350 // The transform hint is used to improve performance, but we can 1351 // only have a single transform hint, it cannot 1352 // apply to all displays. 1353 const Transform& planeTransform(hw->getTransform()); 1354 orientation = planeTransform.getOrientation(); 1355 if (orientation & Transform::ROT_INVALID) { 1356 orientation = 0; 1357 } 1358 } 1359 mSurfaceFlingerConsumer->setTransformHint(orientation); 1360} 1361 1362// ---------------------------------------------------------------------------- 1363// debugging 1364// ---------------------------------------------------------------------------- 1365 1366void Layer::dump(String8& result, Colorizer& colorizer) const 1367{ 1368 const Layer::State& s(getDrawingState()); 1369 1370 colorizer.colorize(result, Colorizer::GREEN); 1371 result.appendFormat( 1372 "+ %s %p (%s)\n", 1373 getTypeId(), this, getName().string()); 1374 colorizer.reset(result); 1375 1376 s.activeTransparentRegion.dump(result, "transparentRegion"); 1377 visibleRegion.dump(result, "visibleRegion"); 1378 surfaceDamageRegion.dump(result, "surfaceDamageRegion"); 1379 sp<Client> client(mClientRef.promote()); 1380 1381 result.appendFormat( " " 1382 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), " 1383 "isOpaque=%1d, invalidate=%1d, " 1384 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 1385 " client=%p\n", 1386 s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h, 1387 s.active.crop.left, s.active.crop.top, 1388 s.active.crop.right, s.active.crop.bottom, 1389 isOpaque(s), contentDirty, 1390 s.alpha, s.flags, 1391 s.transform[0][0], s.transform[0][1], 1392 s.transform[1][0], s.transform[1][1], 1393 client.get()); 1394 1395 sp<const GraphicBuffer> buf0(mActiveBuffer); 1396 uint32_t w0=0, h0=0, s0=0, f0=0; 1397 if (buf0 != 0) { 1398 w0 = buf0->getWidth(); 1399 h0 = buf0->getHeight(); 1400 s0 = buf0->getStride(); 1401 f0 = buf0->format; 1402 } 1403 result.appendFormat( 1404 " " 1405 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 1406 " queued-frames=%d, mRefreshPending=%d\n", 1407 mFormat, w0, h0, s0,f0, 1408 mQueuedFrames, mRefreshPending); 1409 1410 if (mSurfaceFlingerConsumer != 0) { 1411 mSurfaceFlingerConsumer->dump(result, " "); 1412 } 1413} 1414 1415void Layer::dumpFrameStats(String8& result) const { 1416 mFrameTracker.dumpStats(result); 1417} 1418 1419void Layer::clearFrameStats() { 1420 mFrameTracker.clearStats(); 1421} 1422 1423void Layer::logFrameStats() { 1424 mFrameTracker.logAndResetStats(mName); 1425} 1426 1427void Layer::getFrameStats(FrameStats* outStats) const { 1428 mFrameTracker.getStats(outStats); 1429} 1430 1431// --------------------------------------------------------------------------- 1432 1433Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 1434 const sp<Layer>& layer) 1435 : mFlinger(flinger), mLayer(layer) { 1436} 1437 1438Layer::LayerCleaner::~LayerCleaner() { 1439 // destroy client resources 1440 mFlinger->onLayerDestroyed(mLayer); 1441} 1442 1443// --------------------------------------------------------------------------- 1444}; // namespace android 1445 1446#if defined(__gl_h_) 1447#error "don't include gl/gl.h in this file" 1448#endif 1449 1450#if defined(__gl2_h_) 1451#error "don't include gl2/gl2.h in this file" 1452#endif 1453