Layer.cpp revision 231160866738f6ed2175701f300fed1a8e8e02b0
1/* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define ATRACE_TAG ATRACE_TAG_GRAPHICS 18 19#include <stdlib.h> 20#include <stdint.h> 21#include <sys/types.h> 22#include <math.h> 23 24#include <cutils/compiler.h> 25#include <cutils/native_handle.h> 26#include <cutils/properties.h> 27 28#include <utils/Errors.h> 29#include <utils/Log.h> 30#include <utils/NativeHandle.h> 31#include <utils/StopWatch.h> 32#include <utils/Trace.h> 33 34#include <ui/GraphicBuffer.h> 35#include <ui/PixelFormat.h> 36 37#include <gui/BufferItem.h> 38#include <gui/Surface.h> 39 40#include "clz.h" 41#include "Colorizer.h" 42#include "DisplayDevice.h" 43#include "Layer.h" 44#include "MonitoredProducer.h" 45#include "SurfaceFlinger.h" 46 47#include "DisplayHardware/HWComposer.h" 48 49#include "RenderEngine/RenderEngine.h" 50 51#define DEBUG_RESIZE 0 52 53namespace android { 54 55// --------------------------------------------------------------------------- 56 57int32_t Layer::sSequence = 1; 58 59Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client, 60 const String8& name, uint32_t w, uint32_t h, uint32_t flags) 61 : contentDirty(false), 62 sequence(uint32_t(android_atomic_inc(&sSequence))), 63 mFlinger(flinger), 64 mTextureName(-1U), 65 mPremultipliedAlpha(true), 66 mName("unnamed"), 67 mFormat(PIXEL_FORMAT_NONE), 68 mTransactionFlags(0), 69 mQueuedFrames(0), 70 mSidebandStreamChanged(false), 71 mCurrentTransform(0), 72 mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), 73 mCurrentOpacity(true), 74 mRefreshPending(false), 75 mFrameLatencyNeeded(false), 76 mFiltering(false), 77 mNeedsFiltering(false), 78 mMesh(Mesh::TRIANGLE_FAN, 4, 2, 2), 79 mProtectedByApp(false), 80 mHasSurface(false), 81 mClientRef(client), 82 mPotentialCursor(false), 83 mQueueItemLock(), 84 mQueueItemCondition(), 85 mQueueItems(), 86 mLastFrameNumberReceived(0), 87 mUpdateTexImageFailed(false) 88{ 89 mCurrentCrop.makeInvalid(); 90 mFlinger->getRenderEngine().genTextures(1, &mTextureName); 91 mTexture.init(Texture::TEXTURE_EXTERNAL, mTextureName); 92 93 uint32_t layerFlags = 0; 94 if (flags & ISurfaceComposerClient::eHidden) 95 layerFlags |= layer_state_t::eLayerHidden; 96 if (flags & ISurfaceComposerClient::eOpaque) 97 layerFlags |= layer_state_t::eLayerOpaque; 98 if (flags & ISurfaceComposerClient::eSecure) 99 layerFlags |= layer_state_t::eLayerSecure; 100 101 if (flags & ISurfaceComposerClient::eNonPremultiplied) 102 mPremultipliedAlpha = false; 103 104 mName = name; 105 106 mCurrentState.active.w = w; 107 mCurrentState.active.h = h; 108 mCurrentState.active.crop.makeInvalid(); 109 mCurrentState.z = 0; 110 mCurrentState.alpha = 0xFF; 111 mCurrentState.layerStack = 0; 112 mCurrentState.flags = layerFlags; 113 mCurrentState.sequence = 0; 114 mCurrentState.transform.set(0, 0); 115 mCurrentState.requested = mCurrentState.active; 116 117 // drawing state & current state are identical 118 mDrawingState = mCurrentState; 119 120 nsecs_t displayPeriod = 121 flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 122 mFrameTracker.setDisplayRefreshPeriod(displayPeriod); 123} 124 125void Layer::onFirstRef() { 126 // Creates a custom BufferQueue for SurfaceFlingerConsumer to use 127 sp<IGraphicBufferProducer> producer; 128 sp<IGraphicBufferConsumer> consumer; 129 BufferQueue::createBufferQueue(&producer, &consumer); 130 mProducer = new MonitoredProducer(producer, mFlinger); 131 mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName); 132 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 133 mSurfaceFlingerConsumer->setContentsChangedListener(this); 134 mSurfaceFlingerConsumer->setName(mName); 135 136#ifdef TARGET_DISABLE_TRIPLE_BUFFERING 137#warning "disabling triple buffering" 138 mSurfaceFlingerConsumer->setDefaultMaxBufferCount(2); 139#else 140 mSurfaceFlingerConsumer->setDefaultMaxBufferCount(3); 141#endif 142 143 const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); 144 updateTransformHint(hw); 145} 146 147Layer::~Layer() { 148 sp<Client> c(mClientRef.promote()); 149 if (c != 0) { 150 c->detachLayer(this); 151 } 152 mFlinger->deleteTextureAsync(mTextureName); 153 mFrameTracker.logAndResetStats(mName); 154} 155 156// --------------------------------------------------------------------------- 157// callbacks 158// --------------------------------------------------------------------------- 159 160void Layer::onLayerDisplayed(const sp<const DisplayDevice>& /* hw */, 161 HWComposer::HWCLayerInterface* layer) { 162 if (layer) { 163 layer->onDisplayed(); 164 mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFence()); 165 } 166} 167 168void Layer::onFrameAvailable(const BufferItem& item) { 169 // Add this buffer from our internal queue tracker 170 { // Autolock scope 171 Mutex::Autolock lock(mQueueItemLock); 172 173 // Reset the frame number tracker when we receive the first buffer after 174 // a frame number reset 175 if (item.mFrameNumber == 1) { 176 mLastFrameNumberReceived = 0; 177 } 178 179 // Ensure that callbacks are handled in order 180 while (item.mFrameNumber != mLastFrameNumberReceived + 1) { 181 status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, 182 ms2ns(500)); 183 if (result != NO_ERROR) { 184 ALOGE("[%s] Timed out waiting on callback", mName.string()); 185 } 186 } 187 188 mQueueItems.push_back(item); 189 android_atomic_inc(&mQueuedFrames); 190 191 // Wake up any pending callbacks 192 mLastFrameNumberReceived = item.mFrameNumber; 193 mQueueItemCondition.broadcast(); 194 } 195 196 mFlinger->signalLayerUpdate(); 197} 198 199void Layer::onFrameReplaced(const BufferItem& item) { 200 Mutex::Autolock lock(mQueueItemLock); 201 202 // Ensure that callbacks are handled in order 203 while (item.mFrameNumber != mLastFrameNumberReceived + 1) { 204 status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, 205 ms2ns(500)); 206 if (result != NO_ERROR) { 207 ALOGE("[%s] Timed out waiting on callback", mName.string()); 208 } 209 } 210 211 if (mQueueItems.empty()) { 212 ALOGE("Can't replace a frame on an empty queue"); 213 return; 214 } 215 mQueueItems.editItemAt(0) = item; 216 217 // Wake up any pending callbacks 218 mLastFrameNumberReceived = item.mFrameNumber; 219 mQueueItemCondition.broadcast(); 220} 221 222void Layer::onSidebandStreamChanged() { 223 if (android_atomic_release_cas(false, true, &mSidebandStreamChanged) == 0) { 224 // mSidebandStreamChanged was false 225 mFlinger->signalLayerUpdate(); 226 } 227} 228 229// called with SurfaceFlinger::mStateLock from the drawing thread after 230// the layer has been remove from the current state list (and just before 231// it's removed from the drawing state list) 232void Layer::onRemoved() { 233 mSurfaceFlingerConsumer->abandon(); 234} 235 236// --------------------------------------------------------------------------- 237// set-up 238// --------------------------------------------------------------------------- 239 240const String8& Layer::getName() const { 241 return mName; 242} 243 244status_t Layer::setBuffers( uint32_t w, uint32_t h, 245 PixelFormat format, uint32_t flags) 246{ 247 uint32_t const maxSurfaceDims = min( 248 mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); 249 250 // never allow a surface larger than what our underlying GL implementation 251 // can handle. 252 if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) { 253 ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); 254 return BAD_VALUE; 255 } 256 257 mFormat = format; 258 259 mPotentialCursor = (flags & ISurfaceComposerClient::eCursorWindow) ? true : false; 260 mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; 261 mCurrentOpacity = getOpacityForFormat(format); 262 263 mSurfaceFlingerConsumer->setDefaultBufferSize(w, h); 264 mSurfaceFlingerConsumer->setDefaultBufferFormat(format); 265 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 266 267 return NO_ERROR; 268} 269 270sp<IBinder> Layer::getHandle() { 271 Mutex::Autolock _l(mLock); 272 273 LOG_ALWAYS_FATAL_IF(mHasSurface, 274 "Layer::getHandle() has already been called"); 275 276 mHasSurface = true; 277 278 /* 279 * The layer handle is just a BBinder object passed to the client 280 * (remote process) -- we don't keep any reference on our side such that 281 * the dtor is called when the remote side let go of its reference. 282 * 283 * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for 284 * this layer when the handle is destroyed. 285 */ 286 287 class Handle : public BBinder, public LayerCleaner { 288 wp<const Layer> mOwner; 289 public: 290 Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer) 291 : LayerCleaner(flinger, layer), mOwner(layer) { 292 } 293 }; 294 295 return new Handle(mFlinger, this); 296} 297 298sp<IGraphicBufferProducer> Layer::getProducer() const { 299 return mProducer; 300} 301 302// --------------------------------------------------------------------------- 303// h/w composer set-up 304// --------------------------------------------------------------------------- 305 306Rect Layer::getContentCrop() const { 307 // this is the crop rectangle that applies to the buffer 308 // itself (as opposed to the window) 309 Rect crop; 310 if (!mCurrentCrop.isEmpty()) { 311 // if the buffer crop is defined, we use that 312 crop = mCurrentCrop; 313 } else if (mActiveBuffer != NULL) { 314 // otherwise we use the whole buffer 315 crop = mActiveBuffer->getBounds(); 316 } else { 317 // if we don't have a buffer yet, we use an empty/invalid crop 318 crop.makeInvalid(); 319 } 320 return crop; 321} 322 323static Rect reduce(const Rect& win, const Region& exclude) { 324 if (CC_LIKELY(exclude.isEmpty())) { 325 return win; 326 } 327 if (exclude.isRect()) { 328 return win.reduce(exclude.getBounds()); 329 } 330 return Region(win).subtract(exclude).getBounds(); 331} 332 333Rect Layer::computeBounds() const { 334 const Layer::State& s(getDrawingState()); 335 return computeBounds(s.activeTransparentRegion); 336} 337 338Rect Layer::computeBounds(const Region& activeTransparentRegion) const { 339 const Layer::State& s(getDrawingState()); 340 Rect win(s.active.w, s.active.h); 341 if (!s.active.crop.isEmpty()) { 342 win.intersect(s.active.crop, &win); 343 } 344 // subtract the transparent region and snap to the bounds 345 return reduce(win, activeTransparentRegion); 346} 347 348FloatRect Layer::computeCrop(const sp<const DisplayDevice>& hw) const { 349 // the content crop is the area of the content that gets scaled to the 350 // layer's size. 351 FloatRect crop(getContentCrop()); 352 353 // the active.crop is the area of the window that gets cropped, but not 354 // scaled in any ways. 355 const State& s(getDrawingState()); 356 357 // apply the projection's clipping to the window crop in 358 // layerstack space, and convert-back to layer space. 359 // if there are no window scaling involved, this operation will map to full 360 // pixels in the buffer. 361 // FIXME: the 3 lines below can produce slightly incorrect clipping when we have 362 // a viewport clipping and a window transform. we should use floating point to fix this. 363 364 Rect activeCrop(s.active.w, s.active.h); 365 if (!s.active.crop.isEmpty()) { 366 activeCrop = s.active.crop; 367 } 368 369 activeCrop = s.transform.transform(activeCrop); 370 activeCrop.intersect(hw->getViewport(), &activeCrop); 371 activeCrop = s.transform.inverse().transform(activeCrop); 372 373 // This needs to be here as transform.transform(Rect) computes the 374 // transformed rect and then takes the bounding box of the result before 375 // returning. This means 376 // transform.inverse().transform(transform.transform(Rect)) != Rect 377 // in which case we need to make sure the final rect is clipped to the 378 // display bounds. 379 activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop); 380 381 // subtract the transparent region and snap to the bounds 382 activeCrop = reduce(activeCrop, s.activeTransparentRegion); 383 384 if (!activeCrop.isEmpty()) { 385 // Transform the window crop to match the buffer coordinate system, 386 // which means using the inverse of the current transform set on the 387 // SurfaceFlingerConsumer. 388 uint32_t invTransform = mCurrentTransform; 389 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { 390 /* 391 * the code below applies the display's inverse transform to the buffer 392 */ 393 uint32_t invTransformOrient = hw->getOrientationTransform(); 394 // calculate the inverse transform 395 if (invTransformOrient & NATIVE_WINDOW_TRANSFORM_ROT_90) { 396 invTransformOrient ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 397 NATIVE_WINDOW_TRANSFORM_FLIP_H; 398 // If the transform has been rotated the axis of flip has been swapped 399 // so we need to swap which flip operations we are performing 400 bool is_h_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; 401 bool is_v_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; 402 if (is_h_flipped != is_v_flipped) { 403 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 404 NATIVE_WINDOW_TRANSFORM_FLIP_H; 405 } 406 } 407 // and apply to the current transform 408 invTransform = (Transform(invTransform) * Transform(invTransformOrient)).getOrientation(); 409 } 410 411 int winWidth = s.active.w; 412 int winHeight = s.active.h; 413 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 414 // If the activeCrop has been rotate the ends are rotated but not 415 // the space itself so when transforming ends back we can't rely on 416 // a modification of the axes of rotation. To account for this we 417 // need to reorient the inverse rotation in terms of the current 418 // axes of rotation. 419 bool is_h_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; 420 bool is_v_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; 421 if (is_h_flipped == is_v_flipped) { 422 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 423 NATIVE_WINDOW_TRANSFORM_FLIP_H; 424 } 425 winWidth = s.active.h; 426 winHeight = s.active.w; 427 } 428 const Rect winCrop = activeCrop.transform( 429 invTransform, s.active.w, s.active.h); 430 431 // below, crop is intersected with winCrop expressed in crop's coordinate space 432 float xScale = crop.getWidth() / float(winWidth); 433 float yScale = crop.getHeight() / float(winHeight); 434 435 float insetL = winCrop.left * xScale; 436 float insetT = winCrop.top * yScale; 437 float insetR = (winWidth - winCrop.right ) * xScale; 438 float insetB = (winHeight - winCrop.bottom) * yScale; 439 440 crop.left += insetL; 441 crop.top += insetT; 442 crop.right -= insetR; 443 crop.bottom -= insetB; 444 } 445 return crop; 446} 447 448void Layer::setGeometry( 449 const sp<const DisplayDevice>& hw, 450 HWComposer::HWCLayerInterface& layer) 451{ 452 layer.setDefaultState(); 453 454 // enable this layer 455 layer.setSkip(false); 456 457 if (isSecure() && !hw->isSecure()) { 458 layer.setSkip(true); 459 } 460 461 // this gives us only the "orientation" component of the transform 462 const State& s(getDrawingState()); 463 if (!isOpaque(s) || s.alpha != 0xFF) { 464 layer.setBlending(mPremultipliedAlpha ? 465 HWC_BLENDING_PREMULT : 466 HWC_BLENDING_COVERAGE); 467 } 468 469 // apply the layer's transform, followed by the display's global transform 470 // here we're guaranteed that the layer's transform preserves rects 471 Region activeTransparentRegion(s.activeTransparentRegion); 472 if (!s.active.crop.isEmpty()) { 473 Rect activeCrop(s.active.crop); 474 activeCrop = s.transform.transform(activeCrop); 475 activeCrop.intersect(hw->getViewport(), &activeCrop); 476 activeCrop = s.transform.inverse().transform(activeCrop); 477 // This needs to be here as transform.transform(Rect) computes the 478 // transformed rect and then takes the bounding box of the result before 479 // returning. This means 480 // transform.inverse().transform(transform.transform(Rect)) != Rect 481 // in which case we need to make sure the final rect is clipped to the 482 // display bounds. 483 activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop); 484 // mark regions outside the crop as transparent 485 activeTransparentRegion.orSelf(Rect(0, 0, s.active.w, activeCrop.top)); 486 activeTransparentRegion.orSelf(Rect(0, activeCrop.bottom, 487 s.active.w, s.active.h)); 488 activeTransparentRegion.orSelf(Rect(0, activeCrop.top, 489 activeCrop.left, activeCrop.bottom)); 490 activeTransparentRegion.orSelf(Rect(activeCrop.right, activeCrop.top, 491 s.active.w, activeCrop.bottom)); 492 } 493 Rect frame(s.transform.transform(computeBounds(activeTransparentRegion))); 494 frame.intersect(hw->getViewport(), &frame); 495 const Transform& tr(hw->getTransform()); 496 layer.setFrame(tr.transform(frame)); 497 layer.setCrop(computeCrop(hw)); 498 layer.setPlaneAlpha(s.alpha); 499 500 /* 501 * Transformations are applied in this order: 502 * 1) buffer orientation/flip/mirror 503 * 2) state transformation (window manager) 504 * 3) layer orientation (screen orientation) 505 * (NOTE: the matrices are multiplied in reverse order) 506 */ 507 508 const Transform bufferOrientation(mCurrentTransform); 509 Transform transform(tr * s.transform * bufferOrientation); 510 511 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { 512 /* 513 * the code below applies the display's inverse transform to the buffer 514 */ 515 uint32_t invTransform = hw->getOrientationTransform(); 516 uint32_t t_orientation = transform.getOrientation(); 517 // calculate the inverse transform 518 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 519 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 520 NATIVE_WINDOW_TRANSFORM_FLIP_H; 521 // If the transform has been rotated the axis of flip has been swapped 522 // so we need to swap which flip operations we are performing 523 bool is_h_flipped = (t_orientation & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; 524 bool is_v_flipped = (t_orientation & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; 525 if (is_h_flipped != is_v_flipped) { 526 t_orientation ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 527 NATIVE_WINDOW_TRANSFORM_FLIP_H; 528 } 529 } 530 // and apply to the current transform 531 transform = Transform(t_orientation) * Transform(invTransform); 532 } 533 534 // this gives us only the "orientation" component of the transform 535 const uint32_t orientation = transform.getOrientation(); 536 if (orientation & Transform::ROT_INVALID) { 537 // we can only handle simple transformation 538 layer.setSkip(true); 539 } else { 540 layer.setTransform(orientation); 541 } 542} 543 544void Layer::setPerFrameData(const sp<const DisplayDevice>& hw, 545 HWComposer::HWCLayerInterface& layer) { 546 // we have to set the visible region on every frame because 547 // we currently free it during onLayerDisplayed(), which is called 548 // after HWComposer::commit() -- every frame. 549 // Apply this display's projection's viewport to the visible region 550 // before giving it to the HWC HAL. 551 const Transform& tr = hw->getTransform(); 552 Region visible = tr.transform(visibleRegion.intersect(hw->getViewport())); 553 layer.setVisibleRegionScreen(visible); 554 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::isSecure() const 862{ 863 const Layer::State& s(mDrawingState); 864 return (s.flags & layer_state_t::eLayerSecure); 865} 866 867bool Layer::isProtected() const 868{ 869 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 870 return (activeBuffer != 0) && 871 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 872} 873 874bool Layer::isFixedSize() const { 875 return mCurrentScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 876} 877 878bool Layer::isCropped() const { 879 return !mCurrentCrop.isEmpty(); 880} 881 882bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const { 883 return mNeedsFiltering || hw->needsFiltering(); 884} 885 886void Layer::setVisibleRegion(const Region& visibleRegion) { 887 // always called from main thread 888 this->visibleRegion = visibleRegion; 889} 890 891void Layer::setCoveredRegion(const Region& coveredRegion) { 892 // always called from main thread 893 this->coveredRegion = coveredRegion; 894} 895 896void Layer::setVisibleNonTransparentRegion(const Region& 897 setVisibleNonTransparentRegion) { 898 // always called from main thread 899 this->visibleNonTransparentRegion = setVisibleNonTransparentRegion; 900} 901 902// ---------------------------------------------------------------------------- 903// transaction 904// ---------------------------------------------------------------------------- 905 906uint32_t Layer::doTransaction(uint32_t flags) { 907 ATRACE_CALL(); 908 909 const Layer::State& s(getDrawingState()); 910 const Layer::State& c(getCurrentState()); 911 912 const bool sizeChanged = (c.requested.w != s.requested.w) || 913 (c.requested.h != s.requested.h); 914 915 if (sizeChanged) { 916 // the size changed, we need to ask our client to request a new buffer 917 ALOGD_IF(DEBUG_RESIZE, 918 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 919 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 920 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n" 921 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 922 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 923 this, getName().string(), mCurrentTransform, mCurrentScalingMode, 924 c.active.w, c.active.h, 925 c.active.crop.left, 926 c.active.crop.top, 927 c.active.crop.right, 928 c.active.crop.bottom, 929 c.active.crop.getWidth(), 930 c.active.crop.getHeight(), 931 c.requested.w, c.requested.h, 932 c.requested.crop.left, 933 c.requested.crop.top, 934 c.requested.crop.right, 935 c.requested.crop.bottom, 936 c.requested.crop.getWidth(), 937 c.requested.crop.getHeight(), 938 s.active.w, s.active.h, 939 s.active.crop.left, 940 s.active.crop.top, 941 s.active.crop.right, 942 s.active.crop.bottom, 943 s.active.crop.getWidth(), 944 s.active.crop.getHeight(), 945 s.requested.w, s.requested.h, 946 s.requested.crop.left, 947 s.requested.crop.top, 948 s.requested.crop.right, 949 s.requested.crop.bottom, 950 s.requested.crop.getWidth(), 951 s.requested.crop.getHeight()); 952 953 // record the new size, form this point on, when the client request 954 // a buffer, it'll get the new size. 955 mSurfaceFlingerConsumer->setDefaultBufferSize( 956 c.requested.w, c.requested.h); 957 } 958 959 if (!isFixedSize()) { 960 961 const bool resizePending = (c.requested.w != c.active.w) || 962 (c.requested.h != c.active.h); 963 964 if (resizePending && mSidebandStream == NULL) { 965 // don't let Layer::doTransaction update the drawing state 966 // if we have a pending resize, unless we are in fixed-size mode. 967 // the drawing state will be updated only once we receive a buffer 968 // with the correct size. 969 // 970 // in particular, we want to make sure the clip (which is part 971 // of the geometry state) is latched together with the size but is 972 // latched immediately when no resizing is involved. 973 // 974 // If a sideband stream is attached, however, we want to skip this 975 // optimization so that transactions aren't missed when a buffer 976 // never arrives 977 978 flags |= eDontUpdateGeometryState; 979 } 980 } 981 982 // always set active to requested, unless we're asked not to 983 // this is used by Layer, which special cases resizes. 984 if (flags & eDontUpdateGeometryState) { 985 } else { 986 Layer::State& editCurrentState(getCurrentState()); 987 editCurrentState.active = c.requested; 988 } 989 990 if (s.active != c.active) { 991 // invalidate and recompute the visible regions if needed 992 flags |= Layer::eVisibleRegion; 993 } 994 995 if (c.sequence != s.sequence) { 996 // invalidate and recompute the visible regions if needed 997 flags |= eVisibleRegion; 998 this->contentDirty = true; 999 1000 // we may use linear filtering, if the matrix scales us 1001 const uint8_t type = c.transform.getType(); 1002 mNeedsFiltering = (!c.transform.preserveRects() || 1003 (type >= Transform::SCALE)); 1004 } 1005 1006 // Commit the transaction 1007 commitTransaction(); 1008 return flags; 1009} 1010 1011void Layer::commitTransaction() { 1012 mDrawingState = mCurrentState; 1013} 1014 1015uint32_t Layer::getTransactionFlags(uint32_t flags) { 1016 return android_atomic_and(~flags, &mTransactionFlags) & flags; 1017} 1018 1019uint32_t Layer::setTransactionFlags(uint32_t flags) { 1020 return android_atomic_or(flags, &mTransactionFlags); 1021} 1022 1023bool Layer::setPosition(float x, float y) { 1024 if (mCurrentState.transform.tx() == x && mCurrentState.transform.ty() == y) 1025 return false; 1026 mCurrentState.sequence++; 1027 mCurrentState.transform.set(x, y); 1028 setTransactionFlags(eTransactionNeeded); 1029 return true; 1030} 1031bool Layer::setLayer(uint32_t z) { 1032 if (mCurrentState.z == z) 1033 return false; 1034 mCurrentState.sequence++; 1035 mCurrentState.z = z; 1036 setTransactionFlags(eTransactionNeeded); 1037 return true; 1038} 1039bool Layer::setSize(uint32_t w, uint32_t h) { 1040 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 1041 return false; 1042 mCurrentState.requested.w = w; 1043 mCurrentState.requested.h = h; 1044 setTransactionFlags(eTransactionNeeded); 1045 return true; 1046} 1047bool Layer::setAlpha(uint8_t alpha) { 1048 if (mCurrentState.alpha == alpha) 1049 return false; 1050 mCurrentState.sequence++; 1051 mCurrentState.alpha = alpha; 1052 setTransactionFlags(eTransactionNeeded); 1053 return true; 1054} 1055bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 1056 mCurrentState.sequence++; 1057 mCurrentState.transform.set( 1058 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); 1059 setTransactionFlags(eTransactionNeeded); 1060 return true; 1061} 1062bool Layer::setTransparentRegionHint(const Region& transparent) { 1063 mCurrentState.requestedTransparentRegion = transparent; 1064 setTransactionFlags(eTransactionNeeded); 1065 return true; 1066} 1067bool Layer::setFlags(uint8_t flags, uint8_t mask) { 1068 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 1069 if (mCurrentState.flags == newFlags) 1070 return false; 1071 mCurrentState.sequence++; 1072 mCurrentState.flags = newFlags; 1073 setTransactionFlags(eTransactionNeeded); 1074 return true; 1075} 1076bool Layer::setCrop(const Rect& crop) { 1077 if (mCurrentState.requested.crop == crop) 1078 return false; 1079 mCurrentState.sequence++; 1080 mCurrentState.requested.crop = crop; 1081 setTransactionFlags(eTransactionNeeded); 1082 return true; 1083} 1084 1085bool Layer::setLayerStack(uint32_t layerStack) { 1086 if (mCurrentState.layerStack == layerStack) 1087 return false; 1088 mCurrentState.sequence++; 1089 mCurrentState.layerStack = layerStack; 1090 setTransactionFlags(eTransactionNeeded); 1091 return true; 1092} 1093 1094void Layer::useSurfaceDamage() { 1095 if (mFlinger->mForceFullDamage) { 1096 surfaceDamageRegion = Region::INVALID_REGION; 1097 } else { 1098 surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage(); 1099 } 1100} 1101 1102void Layer::useEmptyDamage() { 1103 surfaceDamageRegion.clear(); 1104} 1105 1106// ---------------------------------------------------------------------------- 1107// pageflip handling... 1108// ---------------------------------------------------------------------------- 1109 1110bool Layer::shouldPresentNow(const DispSync& dispSync) const { 1111 Mutex::Autolock lock(mQueueItemLock); 1112 nsecs_t expectedPresent = 1113 mSurfaceFlingerConsumer->computeExpectedPresent(dispSync); 1114 return mQueueItems.empty() ? 1115 false : mQueueItems[0].mTimestamp < expectedPresent; 1116} 1117 1118bool Layer::onPreComposition() { 1119 mRefreshPending = false; 1120 return mQueuedFrames > 0 || mSidebandStreamChanged; 1121} 1122 1123void Layer::onPostComposition() { 1124 if (mFrameLatencyNeeded) { 1125 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 1126 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 1127 1128 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 1129 if (frameReadyFence->isValid()) { 1130 mFrameTracker.setFrameReadyFence(frameReadyFence); 1131 } else { 1132 // There was no fence for this frame, so assume that it was ready 1133 // to be presented at the desired present time. 1134 mFrameTracker.setFrameReadyTime(desiredPresentTime); 1135 } 1136 1137 const HWComposer& hwc = mFlinger->getHwComposer(); 1138 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 1139 if (presentFence->isValid()) { 1140 mFrameTracker.setActualPresentFence(presentFence); 1141 } else { 1142 // The HWC doesn't support present fences, so use the refresh 1143 // timestamp instead. 1144 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 1145 mFrameTracker.setActualPresentTime(presentTime); 1146 } 1147 1148 mFrameTracker.advanceFrame(); 1149 mFrameLatencyNeeded = false; 1150 } 1151} 1152 1153bool Layer::isVisible() const { 1154 const Layer::State& s(mDrawingState); 1155 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha 1156 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1157} 1158 1159Region Layer::latchBuffer(bool& recomputeVisibleRegions) 1160{ 1161 ATRACE_CALL(); 1162 1163 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { 1164 // mSidebandStreamChanged was true 1165 mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream(); 1166 if (mSidebandStream != NULL) { 1167 setTransactionFlags(eTransactionNeeded); 1168 mFlinger->setTransactionFlags(eTraversalNeeded); 1169 } 1170 recomputeVisibleRegions = true; 1171 1172 const State& s(getDrawingState()); 1173 return s.transform.transform(Region(Rect(s.active.w, s.active.h))); 1174 } 1175 1176 Region outDirtyRegion; 1177 if (mQueuedFrames > 0) { 1178 1179 // if we've already called updateTexImage() without going through 1180 // a composition step, we have to skip this layer at this point 1181 // because we cannot call updateTeximage() without a corresponding 1182 // compositionComplete() call. 1183 // we'll trigger an update in onPreComposition(). 1184 if (mRefreshPending) { 1185 return outDirtyRegion; 1186 } 1187 1188 // Capture the old state of the layer for comparisons later 1189 const State& s(getDrawingState()); 1190 const bool oldOpacity = isOpaque(s); 1191 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 1192 1193 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 1194 Layer::State& front; 1195 Layer::State& current; 1196 bool& recomputeVisibleRegions; 1197 bool stickyTransformSet; 1198 Reject(Layer::State& front, Layer::State& current, 1199 bool& recomputeVisibleRegions, bool stickySet) 1200 : front(front), current(current), 1201 recomputeVisibleRegions(recomputeVisibleRegions), 1202 stickyTransformSet(stickySet) { 1203 } 1204 1205 virtual bool reject(const sp<GraphicBuffer>& buf, 1206 const BufferItem& item) { 1207 if (buf == NULL) { 1208 return false; 1209 } 1210 1211 uint32_t bufWidth = buf->getWidth(); 1212 uint32_t bufHeight = buf->getHeight(); 1213 1214 // check that we received a buffer of the right size 1215 // (Take the buffer's orientation into account) 1216 if (item.mTransform & Transform::ROT_90) { 1217 swap(bufWidth, bufHeight); 1218 } 1219 1220 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1221 if (front.active != front.requested) { 1222 1223 if (isFixedSize || 1224 (bufWidth == front.requested.w && 1225 bufHeight == front.requested.h)) 1226 { 1227 // Here we pretend the transaction happened by updating the 1228 // current and drawing states. Drawing state is only accessed 1229 // in this thread, no need to have it locked 1230 front.active = front.requested; 1231 1232 // We also need to update the current state so that 1233 // we don't end-up overwriting the drawing state with 1234 // this stale current state during the next transaction 1235 // 1236 // NOTE: We don't need to hold the transaction lock here 1237 // because State::active is only accessed from this thread. 1238 current.active = front.active; 1239 1240 // recompute visible region 1241 recomputeVisibleRegions = true; 1242 } 1243 1244 ALOGD_IF(DEBUG_RESIZE, 1245 "latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 1246 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1247 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 1248 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 1249 front.active.w, front.active.h, 1250 front.active.crop.left, 1251 front.active.crop.top, 1252 front.active.crop.right, 1253 front.active.crop.bottom, 1254 front.active.crop.getWidth(), 1255 front.active.crop.getHeight(), 1256 front.requested.w, front.requested.h, 1257 front.requested.crop.left, 1258 front.requested.crop.top, 1259 front.requested.crop.right, 1260 front.requested.crop.bottom, 1261 front.requested.crop.getWidth(), 1262 front.requested.crop.getHeight()); 1263 } 1264 1265 if (!isFixedSize && !stickyTransformSet) { 1266 if (front.active.w != bufWidth || 1267 front.active.h != bufHeight) { 1268 // reject this buffer 1269 ALOGE("rejecting buffer: bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}", 1270 bufWidth, bufHeight, front.active.w, front.active.h); 1271 return true; 1272 } 1273 } 1274 1275 // if the transparent region has changed (this test is 1276 // conservative, but that's fine, worst case we're doing 1277 // a bit of extra work), we latch the new one and we 1278 // trigger a visible-region recompute. 1279 if (!front.activeTransparentRegion.isTriviallyEqual( 1280 front.requestedTransparentRegion)) { 1281 front.activeTransparentRegion = front.requestedTransparentRegion; 1282 1283 // We also need to update the current state so that 1284 // we don't end-up overwriting the drawing state with 1285 // this stale current state during the next transaction 1286 // 1287 // NOTE: We don't need to hold the transaction lock here 1288 // because State::active is only accessed from this thread. 1289 current.activeTransparentRegion = front.activeTransparentRegion; 1290 1291 // recompute visible region 1292 recomputeVisibleRegions = true; 1293 } 1294 1295 return false; 1296 } 1297 }; 1298 1299 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 1300 getProducerStickyTransform() != 0); 1301 1302 uint64_t maxFrameNumber = 0; 1303 { 1304 Mutex::Autolock lock(mQueueItemLock); 1305 maxFrameNumber = mLastFrameNumberReceived; 1306 } 1307 1308 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, 1309 mFlinger->mPrimaryDispSync, maxFrameNumber); 1310 if (updateResult == BufferQueue::PRESENT_LATER) { 1311 // Producer doesn't want buffer to be displayed yet. Signal a 1312 // layer update so we check again at the next opportunity. 1313 mFlinger->signalLayerUpdate(); 1314 return outDirtyRegion; 1315 } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) { 1316 // If the buffer has been rejected, remove it from the shadow queue 1317 // and return early 1318 Mutex::Autolock lock(mQueueItemLock); 1319 mQueueItems.removeAt(0); 1320 android_atomic_dec(&mQueuedFrames); 1321 return outDirtyRegion; 1322 } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { 1323 // This can occur if something goes wrong when trying to create the 1324 // EGLImage for this buffer. If this happens, the buffer has already 1325 // been released, so we need to clean up the queue and bug out 1326 // early. 1327 { 1328 Mutex::Autolock lock(mQueueItemLock); 1329 mQueueItems.clear(); 1330 android_atomic_and(0, &mQueuedFrames); 1331 } 1332 1333 // Once we have hit this state, the shadow queue may no longer 1334 // correctly reflect the incoming BufferQueue's contents, so even if 1335 // updateTexImage starts working, the only safe course of action is 1336 // to continue to ignore updates. 1337 mUpdateTexImageFailed = true; 1338 1339 return outDirtyRegion; 1340 } 1341 1342 { // Autolock scope 1343 auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 1344 1345 Mutex::Autolock lock(mQueueItemLock); 1346 1347 // Remove any stale buffers that have been dropped during 1348 // updateTexImage 1349 while (mQueueItems[0].mFrameNumber != currentFrameNumber) { 1350 mQueueItems.removeAt(0); 1351 android_atomic_dec(&mQueuedFrames); 1352 } 1353 1354 mQueueItems.removeAt(0); 1355 } 1356 1357 1358 // Decrement the queued-frames count. Signal another event if we 1359 // have more frames pending. 1360 if (android_atomic_dec(&mQueuedFrames) > 1) { 1361 mFlinger->signalLayerUpdate(); 1362 } 1363 1364 if (updateResult != NO_ERROR) { 1365 // something happened! 1366 recomputeVisibleRegions = true; 1367 return outDirtyRegion; 1368 } 1369 1370 // update the active buffer 1371 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 1372 if (mActiveBuffer == NULL) { 1373 // this can only happen if the very first buffer was rejected. 1374 return outDirtyRegion; 1375 } 1376 1377 mRefreshPending = true; 1378 mFrameLatencyNeeded = true; 1379 if (oldActiveBuffer == NULL) { 1380 // the first time we receive a buffer, we need to trigger a 1381 // geometry invalidation. 1382 recomputeVisibleRegions = true; 1383 } 1384 1385 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 1386 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 1387 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 1388 if ((crop != mCurrentCrop) || 1389 (transform != mCurrentTransform) || 1390 (scalingMode != mCurrentScalingMode)) 1391 { 1392 mCurrentCrop = crop; 1393 mCurrentTransform = transform; 1394 mCurrentScalingMode = scalingMode; 1395 recomputeVisibleRegions = true; 1396 } 1397 1398 if (oldActiveBuffer != NULL) { 1399 uint32_t bufWidth = mActiveBuffer->getWidth(); 1400 uint32_t bufHeight = mActiveBuffer->getHeight(); 1401 if (bufWidth != uint32_t(oldActiveBuffer->width) || 1402 bufHeight != uint32_t(oldActiveBuffer->height)) { 1403 recomputeVisibleRegions = true; 1404 } 1405 } 1406 1407 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 1408 if (oldOpacity != isOpaque(s)) { 1409 recomputeVisibleRegions = true; 1410 } 1411 1412 // FIXME: postedRegion should be dirty & bounds 1413 Region dirtyRegion(Rect(s.active.w, s.active.h)); 1414 1415 // transform the dirty region to window-manager space 1416 outDirtyRegion = (s.transform.transform(dirtyRegion)); 1417 } 1418 return outDirtyRegion; 1419} 1420 1421uint32_t Layer::getEffectiveUsage(uint32_t usage) const 1422{ 1423 // TODO: should we do something special if mSecure is set? 1424 if (mProtectedByApp) { 1425 // need a hardware-protected path to external video sink 1426 usage |= GraphicBuffer::USAGE_PROTECTED; 1427 } 1428 if (mPotentialCursor) { 1429 usage |= GraphicBuffer::USAGE_CURSOR; 1430 } 1431 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 1432 return usage; 1433} 1434 1435void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 1436 uint32_t orientation = 0; 1437 if (!mFlinger->mDebugDisableTransformHint) { 1438 // The transform hint is used to improve performance, but we can 1439 // only have a single transform hint, it cannot 1440 // apply to all displays. 1441 const Transform& planeTransform(hw->getTransform()); 1442 orientation = planeTransform.getOrientation(); 1443 if (orientation & Transform::ROT_INVALID) { 1444 orientation = 0; 1445 } 1446 } 1447 mSurfaceFlingerConsumer->setTransformHint(orientation); 1448} 1449 1450// ---------------------------------------------------------------------------- 1451// debugging 1452// ---------------------------------------------------------------------------- 1453 1454void Layer::dump(String8& result, Colorizer& colorizer) const 1455{ 1456 const Layer::State& s(getDrawingState()); 1457 1458 colorizer.colorize(result, Colorizer::GREEN); 1459 result.appendFormat( 1460 "+ %s %p (%s)\n", 1461 getTypeId(), this, getName().string()); 1462 colorizer.reset(result); 1463 1464 s.activeTransparentRegion.dump(result, "transparentRegion"); 1465 visibleRegion.dump(result, "visibleRegion"); 1466 surfaceDamageRegion.dump(result, "surfaceDamageRegion"); 1467 sp<Client> client(mClientRef.promote()); 1468 1469 result.appendFormat( " " 1470 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), " 1471 "isOpaque=%1d, invalidate=%1d, " 1472 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 1473 " client=%p\n", 1474 s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h, 1475 s.active.crop.left, s.active.crop.top, 1476 s.active.crop.right, s.active.crop.bottom, 1477 isOpaque(s), contentDirty, 1478 s.alpha, s.flags, 1479 s.transform[0][0], s.transform[0][1], 1480 s.transform[1][0], s.transform[1][1], 1481 client.get()); 1482 1483 sp<const GraphicBuffer> buf0(mActiveBuffer); 1484 uint32_t w0=0, h0=0, s0=0, f0=0; 1485 if (buf0 != 0) { 1486 w0 = buf0->getWidth(); 1487 h0 = buf0->getHeight(); 1488 s0 = buf0->getStride(); 1489 f0 = buf0->format; 1490 } 1491 result.appendFormat( 1492 " " 1493 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 1494 " queued-frames=%d, mRefreshPending=%d\n", 1495 mFormat, w0, h0, s0,f0, 1496 mQueuedFrames, mRefreshPending); 1497 1498 if (mSurfaceFlingerConsumer != 0) { 1499 mSurfaceFlingerConsumer->dump(result, " "); 1500 } 1501} 1502 1503void Layer::dumpFrameStats(String8& result) const { 1504 mFrameTracker.dumpStats(result); 1505} 1506 1507void Layer::clearFrameStats() { 1508 mFrameTracker.clearStats(); 1509} 1510 1511void Layer::logFrameStats() { 1512 mFrameTracker.logAndResetStats(mName); 1513} 1514 1515void Layer::getFrameStats(FrameStats* outStats) const { 1516 mFrameTracker.getStats(outStats); 1517} 1518 1519// --------------------------------------------------------------------------- 1520 1521Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger, 1522 const sp<Layer>& layer) 1523 : mFlinger(flinger), mLayer(layer) { 1524} 1525 1526Layer::LayerCleaner::~LayerCleaner() { 1527 // destroy client resources 1528 mFlinger->onLayerDestroyed(mLayer); 1529} 1530 1531// --------------------------------------------------------------------------- 1532}; // namespace android 1533 1534#if defined(__gl_h_) 1535#error "don't include gl/gl.h in this file" 1536#endif 1537 1538#if defined(__gl2_h_) 1539#error "don't include gl2/gl2.h in this file" 1540#endif 1541