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