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