Layer.cpp revision 12e0a27aa30d9db10eafe88904d3eb8fdcbcfa71
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 if (mSidebandStream != NULL) { 1129 setTransactionFlags(eTransactionNeeded); 1130 mFlinger->setTransactionFlags(eTraversalNeeded); 1131 } 1132 recomputeVisibleRegions = true; 1133 1134 const State& s(getDrawingState()); 1135 return s.transform.transform(Region(Rect(s.active.w, s.active.h))); 1136 } 1137 1138 Region outDirtyRegion; 1139 if (mQueuedFrames > 0) { 1140 1141 // if we've already called updateTexImage() without going through 1142 // a composition step, we have to skip this layer at this point 1143 // because we cannot call updateTeximage() without a corresponding 1144 // compositionComplete() call. 1145 // we'll trigger an update in onPreComposition(). 1146 if (mRefreshPending) { 1147 return outDirtyRegion; 1148 } 1149 1150 // Capture the old state of the layer for comparisons later 1151 const State& s(getDrawingState()); 1152 const bool oldOpacity = isOpaque(s); 1153 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 1154 1155 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 1156 Layer::State& front; 1157 Layer::State& current; 1158 bool& recomputeVisibleRegions; 1159 bool stickyTransformSet; 1160 Reject(Layer::State& front, Layer::State& current, 1161 bool& recomputeVisibleRegions, bool stickySet) 1162 : front(front), current(current), 1163 recomputeVisibleRegions(recomputeVisibleRegions), 1164 stickyTransformSet(stickySet) { 1165 } 1166 1167 virtual bool reject(const sp<GraphicBuffer>& buf, 1168 const BufferItem& item) { 1169 if (buf == NULL) { 1170 return false; 1171 } 1172 1173 uint32_t bufWidth = buf->getWidth(); 1174 uint32_t bufHeight = buf->getHeight(); 1175 1176 // check that we received a buffer of the right size 1177 // (Take the buffer's orientation into account) 1178 if (item.mTransform & Transform::ROT_90) { 1179 swap(bufWidth, bufHeight); 1180 } 1181 1182 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1183 if (front.active != front.requested) { 1184 1185 if (isFixedSize || 1186 (bufWidth == front.requested.w && 1187 bufHeight == front.requested.h)) 1188 { 1189 // Here we pretend the transaction happened by updating the 1190 // current and drawing states. Drawing state is only accessed 1191 // in this thread, no need to have it locked 1192 front.active = front.requested; 1193 1194 // We also need to update the current state so that 1195 // we don't end-up overwriting the drawing state with 1196 // this stale current state during the next transaction 1197 // 1198 // NOTE: We don't need to hold the transaction lock here 1199 // because State::active is only accessed from this thread. 1200 current.active = front.active; 1201 1202 // recompute visible region 1203 recomputeVisibleRegions = true; 1204 } 1205 1206 ALOGD_IF(DEBUG_RESIZE, 1207 "latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 1208 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1209 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 1210 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 1211 front.active.w, front.active.h, 1212 front.active.crop.left, 1213 front.active.crop.top, 1214 front.active.crop.right, 1215 front.active.crop.bottom, 1216 front.active.crop.getWidth(), 1217 front.active.crop.getHeight(), 1218 front.requested.w, front.requested.h, 1219 front.requested.crop.left, 1220 front.requested.crop.top, 1221 front.requested.crop.right, 1222 front.requested.crop.bottom, 1223 front.requested.crop.getWidth(), 1224 front.requested.crop.getHeight()); 1225 } 1226 1227 if (!isFixedSize && !stickyTransformSet) { 1228 if (front.active.w != bufWidth || 1229 front.active.h != bufHeight) { 1230 // reject this buffer 1231 ALOGE("rejecting buffer: bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}", 1232 bufWidth, bufHeight, front.active.w, front.active.h); 1233 return true; 1234 } 1235 } 1236 1237 // if the transparent region has changed (this test is 1238 // conservative, but that's fine, worst case we're doing 1239 // a bit of extra work), we latch the new one and we 1240 // trigger a visible-region recompute. 1241 if (!front.activeTransparentRegion.isTriviallyEqual( 1242 front.requestedTransparentRegion)) { 1243 front.activeTransparentRegion = front.requestedTransparentRegion; 1244 1245 // We also need to update the current state so that 1246 // we don't end-up overwriting the drawing state with 1247 // this stale current state during the next transaction 1248 // 1249 // NOTE: We don't need to hold the transaction lock here 1250 // because State::active is only accessed from this thread. 1251 current.activeTransparentRegion = front.activeTransparentRegion; 1252 1253 // recompute visible region 1254 recomputeVisibleRegions = true; 1255 } 1256 1257 return false; 1258 } 1259 }; 1260 1261 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 1262 getProducerStickyTransform() != 0); 1263 1264 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, 1265 mFlinger->mPrimaryDispSync); 1266 if (updateResult == BufferQueue::PRESENT_LATER) { 1267 // Producer doesn't want buffer to be displayed yet. Signal a 1268 // layer update so we check again at the next opportunity. 1269 mFlinger->signalLayerUpdate(); 1270 return outDirtyRegion; 1271 } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) { 1272 // If the buffer has been rejected, remove it from the shadow queue 1273 // and return early 1274 Mutex::Autolock lock(mQueueItemLock); 1275 1276 // Update the BufferQueue with the new shadow queue size after 1277 // dropping this item 1278 mQueueItems.removeAt(0); 1279 mSurfaceFlingerConsumer->setShadowQueueSize(mQueueItems.size()); 1280 1281 android_atomic_dec(&mQueuedFrames); 1282 return outDirtyRegion; 1283 } 1284 1285 { // Autolock scope 1286 auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 1287 1288 Mutex::Autolock lock(mQueueItemLock); 1289 1290 // Remove any stale buffers that have been dropped during 1291 // updateTexImage 1292 while (mQueueItems[0].mFrameNumber != currentFrameNumber) { 1293 mQueueItems.removeAt(0); 1294 android_atomic_dec(&mQueuedFrames); 1295 } 1296 1297 // Update the BufferQueue with our new shadow queue size, since we 1298 // have removed at least one item 1299 mQueueItems.removeAt(0); 1300 mSurfaceFlingerConsumer->setShadowQueueSize(mQueueItems.size()); 1301 } 1302 1303 1304 // Decrement the queued-frames count. Signal another event if we 1305 // have more frames pending. 1306 if (android_atomic_dec(&mQueuedFrames) > 1) { 1307 mFlinger->signalLayerUpdate(); 1308 } 1309 1310 if (updateResult != NO_ERROR) { 1311 // something happened! 1312 recomputeVisibleRegions = true; 1313 return outDirtyRegion; 1314 } 1315 1316 // update the active buffer 1317 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 1318 if (mActiveBuffer == NULL) { 1319 // this can only happen if the very first buffer was rejected. 1320 return outDirtyRegion; 1321 } 1322 1323 mRefreshPending = true; 1324 mFrameLatencyNeeded = true; 1325 if (oldActiveBuffer == NULL) { 1326 // the first time we receive a buffer, we need to trigger a 1327 // geometry invalidation. 1328 recomputeVisibleRegions = true; 1329 } 1330 1331 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 1332 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 1333 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 1334 if ((crop != mCurrentCrop) || 1335 (transform != mCurrentTransform) || 1336 (scalingMode != mCurrentScalingMode)) 1337 { 1338 mCurrentCrop = crop; 1339 mCurrentTransform = transform; 1340 mCurrentScalingMode = scalingMode; 1341 recomputeVisibleRegions = true; 1342 } 1343 1344 if (oldActiveBuffer != NULL) { 1345 uint32_t bufWidth = mActiveBuffer->getWidth(); 1346 uint32_t bufHeight = mActiveBuffer->getHeight(); 1347 if (bufWidth != uint32_t(oldActiveBuffer->width) || 1348 bufHeight != uint32_t(oldActiveBuffer->height)) { 1349 recomputeVisibleRegions = true; 1350 } 1351 } 1352 1353 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 1354 if (oldOpacity != isOpaque(s)) { 1355 recomputeVisibleRegions = true; 1356 } 1357 1358 // FIXME: postedRegion should be dirty & bounds 1359 Region dirtyRegion(Rect(s.active.w, s.active.h)); 1360 1361 // transform the dirty region to window-manager space 1362 outDirtyRegion = (s.transform.transform(dirtyRegion)); 1363 } 1364 return outDirtyRegion; 1365} 1366 1367uint32_t Layer::getEffectiveUsage(uint32_t usage) const 1368{ 1369 // TODO: should we do something special if mSecure is set? 1370 if (mProtectedByApp) { 1371 // need a hardware-protected path to external video sink 1372 usage |= GraphicBuffer::USAGE_PROTECTED; 1373 } 1374 if (mPotentialCursor) { 1375 usage |= GraphicBuffer::USAGE_CURSOR; 1376 } 1377 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 1378 return usage; 1379} 1380 1381void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 1382 uint32_t orientation = 0; 1383 if (!mFlinger->mDebugDisableTransformHint) { 1384 // The transform hint is used to improve performance, but we can 1385 // only have a single transform hint, it cannot 1386 // apply to all displays. 1387 const Transform& planeTransform(hw->getTransform()); 1388 orientation = planeTransform.getOrientation(); 1389 if (orientation & Transform::ROT_INVALID) { 1390 orientation = 0; 1391 } 1392 } 1393 mSurfaceFlingerConsumer->setTransformHint(orientation); 1394} 1395 1396// ---------------------------------------------------------------------------- 1397// debugging 1398// ---------------------------------------------------------------------------- 1399 1400void Layer::dump(String8& result, Colorizer& colorizer) const 1401{ 1402 const Layer::State& s(getDrawingState()); 1403 1404 colorizer.colorize(result, Colorizer::GREEN); 1405 result.appendFormat( 1406 "+ %s %p (%s)\n", 1407 getTypeId(), this, getName().string()); 1408 colorizer.reset(result); 1409 1410 s.activeTransparentRegion.dump(result, "transparentRegion"); 1411 visibleRegion.dump(result, "visibleRegion"); 1412 surfaceDamageRegion.dump(result, "surfaceDamageRegion"); 1413 sp<Client> client(mClientRef.promote()); 1414 1415 result.appendFormat( " " 1416 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), " 1417 "isOpaque=%1d, invalidate=%1d, " 1418 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 1419 " client=%p\n", 1420 s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h, 1421 s.active.crop.left, s.active.crop.top, 1422 s.active.crop.right, s.active.crop.bottom, 1423 isOpaque(s), contentDirty, 1424 s.alpha, s.flags, 1425 s.transform[0][0], s.transform[0][1], 1426 s.transform[1][0], s.transform[1][1], 1427 client.get()); 1428 1429 sp<const GraphicBuffer> buf0(mActiveBuffer); 1430 uint32_t w0=0, h0=0, s0=0, f0=0; 1431 if (buf0 != 0) { 1432 w0 = buf0->getWidth(); 1433 h0 = buf0->getHeight(); 1434 s0 = buf0->getStride(); 1435 f0 = buf0->format; 1436 } 1437 result.appendFormat( 1438 " " 1439 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 1440 " queued-frames=%d, mRefreshPending=%d\n", 1441 mFormat, w0, h0, s0,f0, 1442 mQueuedFrames, mRefreshPending); 1443 1444 if (mSurfaceFlingerConsumer != 0) { 1445 mSurfaceFlingerConsumer->dump(result, " "); 1446 } 1447} 1448 1449void Layer::dumpFrameStats(String8& result) const { 1450 mFrameTracker.dumpStats(result); 1451} 1452 1453void Layer::clearFrameStats() { 1454 mFrameTracker.clearStats(); 1455} 1456 1457void Layer::logFrameStats() { 1458 mFrameTracker.logAndResetStats(mName); 1459} 1460 1461void Layer::getFrameStats(FrameStats* outStats) const { 1462 mFrameTracker.getStats(outStats); 1463} 1464 1465// --------------------------------------------------------------------------- 1466 1467Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 1468 const sp<Layer>& layer) 1469 : mFlinger(flinger), mLayer(layer) { 1470} 1471 1472Layer::LayerCleaner::~LayerCleaner() { 1473 // destroy client resources 1474 mFlinger->onLayerDestroyed(mLayer); 1475} 1476 1477// --------------------------------------------------------------------------- 1478}; // namespace android 1479 1480#if defined(__gl_h_) 1481#error "don't include gl/gl.h in this file" 1482#endif 1483 1484#if defined(__gl2_h_) 1485#error "don't include gl2/gl2.h in this file" 1486#endif 1487