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