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