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