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