Layer.cpp revision 3941cb240d438bfdebe24920bb2ada86456a0bf9
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/StopWatch.h> 31#include <utils/Trace.h> 32 33#include <ui/GraphicBuffer.h> 34#include <ui/PixelFormat.h> 35 36#include <gui/Surface.h> 37 38#include "clz.h" 39#include "DisplayDevice.h" 40#include "GLExtensions.h" 41#include "Layer.h" 42#include "SurfaceFlinger.h" 43#include "SurfaceTextureLayer.h" 44 45#include "DisplayHardware/HWComposer.h" 46 47#define DEBUG_RESIZE 0 48 49namespace android { 50 51// --------------------------------------------------------------------------- 52 53Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client) 54 : LayerBaseClient(flinger, client), 55 mTextureName(-1U), 56 mQueuedFrames(0), 57 mCurrentTransform(0), 58 mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), 59 mCurrentOpacity(true), 60 mRefreshPending(false), 61 mFrameLatencyNeeded(false), 62 mFrameLatencyOffset(0), 63 mFormat(PIXEL_FORMAT_NONE), 64 mGLExtensions(GLExtensions::getInstance()), 65 mOpaqueLayer(true), 66 mSecure(false), 67 mProtectedByApp(false) 68{ 69 mCurrentCrop.makeInvalid(); 70 glGenTextures(1, &mTextureName); 71} 72 73void Layer::onLayerDisplayed(const sp<const DisplayDevice>& hw, 74 HWComposer::HWCLayerInterface* layer) { 75 LayerBaseClient::onLayerDisplayed(hw, layer); 76 if (layer) { 77 mSurfaceTexture->setReleaseFence(layer->getAndResetReleaseFenceFd()); 78 } 79} 80 81void Layer::onFirstRef() 82{ 83 LayerBaseClient::onFirstRef(); 84 85 struct FrameQueuedListener : public SurfaceTexture::FrameAvailableListener { 86 FrameQueuedListener(Layer* layer) : mLayer(layer) { } 87 private: 88 wp<Layer> mLayer; 89 virtual void onFrameAvailable() { 90 sp<Layer> that(mLayer.promote()); 91 if (that != 0) { 92 that->onFrameQueued(); 93 } 94 } 95 }; 96 97 // Creates a custom BufferQueue for SurfaceTexture to use 98 sp<BufferQueue> bq = new SurfaceTextureLayer(); 99 mSurfaceTexture = new SurfaceTexture(mTextureName, true, 100 GL_TEXTURE_EXTERNAL_OES, false, bq); 101 102 mSurfaceTexture->setConsumerUsageBits(getEffectiveUsage(0)); 103 mSurfaceTexture->setFrameAvailableListener(new FrameQueuedListener(this)); 104 mSurfaceTexture->setSynchronousMode(true); 105 106#ifdef TARGET_DISABLE_TRIPLE_BUFFERING 107#warning "disabling triple buffering" 108 mSurfaceTexture->setDefaultMaxBufferCount(2); 109#else 110 mSurfaceTexture->setDefaultMaxBufferCount(3); 111#endif 112 113 updateTransformHint(); 114} 115 116Layer::~Layer() 117{ 118 mFlinger->deleteTextureAsync(mTextureName); 119} 120 121void Layer::onFrameQueued() { 122 android_atomic_inc(&mQueuedFrames); 123 mFlinger->signalLayerUpdate(); 124} 125 126// called with SurfaceFlinger::mStateLock as soon as the layer is entered 127// in the purgatory list 128void Layer::onRemoved() 129{ 130 mSurfaceTexture->abandon(); 131} 132 133void Layer::setName(const String8& name) { 134 LayerBase::setName(name); 135 mSurfaceTexture->setName(name); 136} 137 138sp<ISurface> Layer::createSurface() 139{ 140 class BSurface : public BnSurface, public LayerCleaner { 141 wp<const Layer> mOwner; 142 virtual sp<ISurfaceTexture> getSurfaceTexture() const { 143 sp<ISurfaceTexture> res; 144 sp<const Layer> that( mOwner.promote() ); 145 if (that != NULL) { 146 res = that->mSurfaceTexture->getBufferQueue(); 147 } 148 return res; 149 } 150 public: 151 BSurface(const sp<SurfaceFlinger>& flinger, 152 const sp<Layer>& layer) 153 : LayerCleaner(flinger, layer), mOwner(layer) { } 154 }; 155 sp<ISurface> sur(new BSurface(mFlinger, this)); 156 return sur; 157} 158 159wp<IBinder> Layer::getSurfaceTextureBinder() const 160{ 161 return mSurfaceTexture->getBufferQueue()->asBinder(); 162} 163 164status_t Layer::setBuffers( uint32_t w, uint32_t h, 165 PixelFormat format, uint32_t flags) 166{ 167 // this surfaces pixel format 168 PixelFormatInfo info; 169 status_t err = getPixelFormatInfo(format, &info); 170 if (err) { 171 ALOGE("unsupported pixelformat %d", format); 172 return err; 173 } 174 175 uint32_t const maxSurfaceDims = min( 176 mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); 177 178 // never allow a surface larger than what our underlying GL implementation 179 // can handle. 180 if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) { 181 ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); 182 return BAD_VALUE; 183 } 184 185 mFormat = format; 186 187 mSecure = (flags & ISurfaceComposerClient::eSecure) ? true : false; 188 mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; 189 mOpaqueLayer = (flags & ISurfaceComposerClient::eOpaque); 190 mCurrentOpacity = getOpacityForFormat(format); 191 192 mSurfaceTexture->setDefaultBufferSize(w, h); 193 mSurfaceTexture->setDefaultBufferFormat(format); 194 mSurfaceTexture->setConsumerUsageBits(getEffectiveUsage(0)); 195 196 return NO_ERROR; 197} 198 199Rect Layer::computeBufferCrop() const { 200 // Start with the SurfaceTexture's buffer crop... 201 Rect crop; 202 if (!mCurrentCrop.isEmpty()) { 203 crop = mCurrentCrop; 204 } else if (mActiveBuffer != NULL){ 205 crop = Rect(mActiveBuffer->getWidth(), mActiveBuffer->getHeight()); 206 } else { 207 crop.makeInvalid(); 208 return crop; 209 } 210 211 // ... then reduce that in the same proportions as the window crop reduces 212 // the window size. 213 const State& s(drawingState()); 214 if (!s.active.crop.isEmpty()) { 215 // Transform the window crop to match the buffer coordinate system, 216 // which means using the inverse of the current transform set on the 217 // SurfaceTexture. 218 uint32_t invTransform = mCurrentTransform; 219 int winWidth = s.active.w; 220 int winHeight = s.active.h; 221 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 222 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 223 NATIVE_WINDOW_TRANSFORM_FLIP_H; 224 winWidth = s.active.h; 225 winHeight = s.active.w; 226 } 227 Rect winCrop = s.active.crop.transform(invTransform, 228 s.active.w, s.active.h); 229 230 float xScale = float(crop.width()) / float(winWidth); 231 float yScale = float(crop.height()) / float(winHeight); 232 crop.left += int(ceilf(float(winCrop.left) * xScale)); 233 crop.top += int(ceilf(float(winCrop.top) * yScale)); 234 crop.right -= int(ceilf(float(winWidth - winCrop.right) * xScale)); 235 crop.bottom -= int(ceilf(float(winHeight - winCrop.bottom) * yScale)); 236 } 237 238 return crop; 239} 240 241void Layer::setGeometry( 242 const sp<const DisplayDevice>& hw, 243 HWComposer::HWCLayerInterface& layer) 244{ 245 LayerBaseClient::setGeometry(hw, layer); 246 247 // enable this layer 248 layer.setSkip(false); 249 250 // we can't do alpha-fade with the hwc HAL 251 const State& s(drawingState()); 252 if (s.alpha < 0xFF) { 253 layer.setSkip(true); 254 } 255 256 /* 257 * Transformations are applied in this order: 258 * 1) buffer orientation/flip/mirror 259 * 2) state transformation (window manager) 260 * 3) layer orientation (screen orientation) 261 * (NOTE: the matrices are multiplied in reverse order) 262 */ 263 264 const Transform bufferOrientation(mCurrentTransform); 265 const Transform tr(hw->getTransform() * s.transform * bufferOrientation); 266 267 // this gives us only the "orientation" component of the transform 268 const uint32_t finalTransform = tr.getOrientation(); 269 270 // we can only handle simple transformation 271 if (finalTransform & Transform::ROT_INVALID) { 272 layer.setSkip(true); 273 } else { 274 layer.setTransform(finalTransform); 275 } 276 layer.setCrop(computeBufferCrop()); 277} 278 279void Layer::setPerFrameData(const sp<const DisplayDevice>& hw, 280 HWComposer::HWCLayerInterface& layer) { 281 LayerBaseClient::setPerFrameData(hw, layer); 282 // NOTE: buffer can be NULL if the client never drew into this 283 // layer yet, or if we ran out of memory 284 layer.setBuffer(mActiveBuffer); 285} 286 287void Layer::setAcquireFence(const sp<const DisplayDevice>& hw, 288 HWComposer::HWCLayerInterface& layer) { 289 int fenceFd = -1; 290 291 // TODO: there is a possible optimization here: we only need to set the 292 // acquire fence the first time a new buffer is acquired on EACH display. 293 294 if (layer.getCompositionType() == HWC_OVERLAY) { 295 sp<Fence> fence = mSurfaceTexture->getCurrentFence(); 296 if (fence.get()) { 297 fenceFd = fence->dup(); 298 if (fenceFd == -1) { 299 ALOGW("failed to dup layer fence, skipping sync: %d", errno); 300 } 301 } 302 } 303 layer.setAcquireFenceFd(fenceFd); 304} 305 306void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip) const 307{ 308 ATRACE_CALL(); 309 310 if (CC_UNLIKELY(mActiveBuffer == 0)) { 311 // the texture has not been created yet, this Layer has 312 // in fact never been drawn into. This happens frequently with 313 // SurfaceView because the WindowManager can't know when the client 314 // has drawn the first time. 315 316 // If there is nothing under us, we paint the screen in black, otherwise 317 // we just skip this update. 318 319 // figure out if there is something below us 320 Region under; 321 const SurfaceFlinger::LayerVector& drawingLayers( 322 mFlinger->mDrawingState.layersSortedByZ); 323 const size_t count = drawingLayers.size(); 324 for (size_t i=0 ; i<count ; ++i) { 325 const sp<LayerBase>& layer(drawingLayers[i]); 326 if (layer.get() == static_cast<LayerBase const*>(this)) 327 break; 328 under.orSelf( hw->getTransform().transform(layer->visibleRegion) ); 329 } 330 // if not everything below us is covered, we plug the holes! 331 Region holes(clip.subtract(under)); 332 if (!holes.isEmpty()) { 333 clearWithOpenGL(hw, holes, 0, 0, 0, 1); 334 } 335 return; 336 } 337 338 status_t err = mSurfaceTexture->doGLFenceWait(); 339 if (err != OK) { 340 ALOGE("onDraw: failed waiting for fence: %d", err); 341 // Go ahead and draw the buffer anyway; no matter what we do the screen 342 // is probably going to have something visibly wrong. 343 } 344 345 if (!isProtected()) { 346 // TODO: we could be more subtle with isFixedSize() 347 const bool useFiltering = getFiltering() || needsFiltering() || isFixedSize(); 348 349 // Query the texture matrix given our current filtering mode. 350 float textureMatrix[16]; 351 mSurfaceTexture->setFilteringEnabled(useFiltering); 352 mSurfaceTexture->getTransformMatrix(textureMatrix); 353 354 // Set things up for texturing. 355 glBindTexture(GL_TEXTURE_EXTERNAL_OES, mTextureName); 356 GLenum filter = GL_NEAREST; 357 if (useFiltering) { 358 filter = GL_LINEAR; 359 } 360 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, filter); 361 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, filter); 362 glMatrixMode(GL_TEXTURE); 363 glLoadMatrixf(textureMatrix); 364 glMatrixMode(GL_MODELVIEW); 365 glDisable(GL_TEXTURE_2D); 366 glEnable(GL_TEXTURE_EXTERNAL_OES); 367 } else { 368 glBindTexture(GL_TEXTURE_2D, mFlinger->getProtectedTexName()); 369 glMatrixMode(GL_TEXTURE); 370 glLoadIdentity(); 371 glMatrixMode(GL_MODELVIEW); 372 glDisable(GL_TEXTURE_EXTERNAL_OES); 373 glEnable(GL_TEXTURE_2D); 374 } 375 376 drawWithOpenGL(hw, clip); 377 378 glDisable(GL_TEXTURE_EXTERNAL_OES); 379 glDisable(GL_TEXTURE_2D); 380} 381 382// As documented in libhardware header, formats in the range 383// 0x100 - 0x1FF are specific to the HAL implementation, and 384// are known to have no alpha channel 385// TODO: move definition for device-specific range into 386// hardware.h, instead of using hard-coded values here. 387#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) 388 389bool Layer::getOpacityForFormat(uint32_t format) 390{ 391 if (HARDWARE_IS_DEVICE_FORMAT(format)) { 392 return true; 393 } 394 PixelFormatInfo info; 395 status_t err = getPixelFormatInfo(PixelFormat(format), &info); 396 // in case of error (unknown format), we assume no blending 397 return (err || info.h_alpha <= info.l_alpha); 398} 399 400 401bool Layer::isOpaque() const 402{ 403 // if we don't have a buffer yet, we're translucent regardless of the 404 // layer's opaque flag. 405 if (mActiveBuffer == 0) { 406 return false; 407 } 408 409 // if the layer has the opaque flag, then we're always opaque, 410 // otherwise we use the current buffer's format. 411 return mOpaqueLayer || mCurrentOpacity; 412} 413 414bool Layer::isProtected() const 415{ 416 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 417 return (activeBuffer != 0) && 418 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 419} 420 421uint32_t Layer::doTransaction(uint32_t flags) 422{ 423 ATRACE_CALL(); 424 425 const Layer::State& front(drawingState()); 426 const Layer::State& temp(currentState()); 427 428 const bool sizeChanged = (temp.requested.w != front.requested.w) || 429 (temp.requested.h != front.requested.h); 430 431 if (sizeChanged) { 432 // the size changed, we need to ask our client to request a new buffer 433 ALOGD_IF(DEBUG_RESIZE, 434 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 435 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 436 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n" 437 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 438 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 439 this, (const char*) getName(), mCurrentTransform, mCurrentScalingMode, 440 temp.active.w, temp.active.h, 441 temp.active.crop.left, 442 temp.active.crop.top, 443 temp.active.crop.right, 444 temp.active.crop.bottom, 445 temp.active.crop.getWidth(), 446 temp.active.crop.getHeight(), 447 temp.requested.w, temp.requested.h, 448 temp.requested.crop.left, 449 temp.requested.crop.top, 450 temp.requested.crop.right, 451 temp.requested.crop.bottom, 452 temp.requested.crop.getWidth(), 453 temp.requested.crop.getHeight(), 454 front.active.w, front.active.h, 455 front.active.crop.left, 456 front.active.crop.top, 457 front.active.crop.right, 458 front.active.crop.bottom, 459 front.active.crop.getWidth(), 460 front.active.crop.getHeight(), 461 front.requested.w, front.requested.h, 462 front.requested.crop.left, 463 front.requested.crop.top, 464 front.requested.crop.right, 465 front.requested.crop.bottom, 466 front.requested.crop.getWidth(), 467 front.requested.crop.getHeight()); 468 469 // record the new size, form this point on, when the client request 470 // a buffer, it'll get the new size. 471 mSurfaceTexture->setDefaultBufferSize( 472 temp.requested.w, temp.requested.h); 473 } 474 475 if (!isFixedSize()) { 476 477 const bool resizePending = (temp.requested.w != temp.active.w) || 478 (temp.requested.h != temp.active.h); 479 480 if (resizePending) { 481 // don't let LayerBase::doTransaction update the drawing state 482 // if we have a pending resize, unless we are in fixed-size mode. 483 // the drawing state will be updated only once we receive a buffer 484 // with the correct size. 485 // 486 // in particular, we want to make sure the clip (which is part 487 // of the geometry state) is latched together with the size but is 488 // latched immediately when no resizing is involved. 489 490 flags |= eDontUpdateGeometryState; 491 } 492 } 493 494 return LayerBase::doTransaction(flags); 495} 496 497bool Layer::isFixedSize() const { 498 return mCurrentScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 499} 500 501bool Layer::isCropped() const { 502 return !mCurrentCrop.isEmpty(); 503} 504 505// ---------------------------------------------------------------------------- 506// pageflip handling... 507// ---------------------------------------------------------------------------- 508 509bool Layer::onPreComposition() { 510 mRefreshPending = false; 511 return mQueuedFrames > 0; 512} 513 514void Layer::onPostComposition() { 515 if (mFrameLatencyNeeded) { 516 const HWComposer& hwc = mFlinger->getHwComposer(); 517 const size_t offset = mFrameLatencyOffset; 518 mFrameStats[offset].timestamp = mSurfaceTexture->getTimestamp(); 519 mFrameStats[offset].set = systemTime(); 520 mFrameStats[offset].vsync = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 521 mFrameLatencyOffset = (mFrameLatencyOffset + 1) % 128; 522 mFrameLatencyNeeded = false; 523 } 524} 525 526bool Layer::isVisible() const { 527 return LayerBaseClient::isVisible() && (mActiveBuffer != NULL); 528} 529 530Region Layer::latchBuffer(bool& recomputeVisibleRegions) 531{ 532 ATRACE_CALL(); 533 534 Region outDirtyRegion; 535 if (mQueuedFrames > 0) { 536 537 // if we've already called updateTexImage() without going through 538 // a composition step, we have to skip this layer at this point 539 // because we cannot call updateTeximage() without a corresponding 540 // compositionComplete() call. 541 // we'll trigger an update in onPreComposition(). 542 if (mRefreshPending) { 543 return outDirtyRegion; 544 } 545 546 // Capture the old state of the layer for comparisons later 547 const bool oldOpacity = isOpaque(); 548 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 549 550 // signal another event if we have more frames pending 551 if (android_atomic_dec(&mQueuedFrames) > 1) { 552 mFlinger->signalLayerUpdate(); 553 } 554 555 struct Reject : public SurfaceTexture::BufferRejecter { 556 Layer::State& front; 557 Layer::State& current; 558 bool& recomputeVisibleRegions; 559 Reject(Layer::State& front, Layer::State& current, 560 bool& recomputeVisibleRegions) 561 : front(front), current(current), 562 recomputeVisibleRegions(recomputeVisibleRegions) { 563 } 564 565 virtual bool reject(const sp<GraphicBuffer>& buf, 566 const BufferQueue::BufferItem& item) { 567 if (buf == NULL) { 568 return false; 569 } 570 571 uint32_t bufWidth = buf->getWidth(); 572 uint32_t bufHeight = buf->getHeight(); 573 574 // check that we received a buffer of the right size 575 // (Take the buffer's orientation into account) 576 if (item.mTransform & Transform::ROT_90) { 577 swap(bufWidth, bufHeight); 578 } 579 580 581 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 582 if (front.active != front.requested) { 583 584 if (isFixedSize || 585 (bufWidth == front.requested.w && 586 bufHeight == front.requested.h)) 587 { 588 // Here we pretend the transaction happened by updating the 589 // current and drawing states. Drawing state is only accessed 590 // in this thread, no need to have it locked 591 front.active = front.requested; 592 593 // We also need to update the current state so that 594 // we don't end-up overwriting the drawing state with 595 // this stale current state during the next transaction 596 // 597 // NOTE: We don't need to hold the transaction lock here 598 // because State::active is only accessed from this thread. 599 current.active = front.active; 600 601 // recompute visible region 602 recomputeVisibleRegions = true; 603 } 604 605 ALOGD_IF(DEBUG_RESIZE, 606 "latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 607 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 608 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 609 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 610 front.active.w, front.active.h, 611 front.active.crop.left, 612 front.active.crop.top, 613 front.active.crop.right, 614 front.active.crop.bottom, 615 front.active.crop.getWidth(), 616 front.active.crop.getHeight(), 617 front.requested.w, front.requested.h, 618 front.requested.crop.left, 619 front.requested.crop.top, 620 front.requested.crop.right, 621 front.requested.crop.bottom, 622 front.requested.crop.getWidth(), 623 front.requested.crop.getHeight()); 624 } 625 626 if (!isFixedSize) { 627 if (front.active.w != bufWidth || 628 front.active.h != bufHeight) { 629 // reject this buffer 630 return true; 631 } 632 } 633 return false; 634 } 635 }; 636 637 638 Reject r(mDrawingState, currentState(), recomputeVisibleRegions); 639 640 if (mSurfaceTexture->updateTexImage(&r, true) < NO_ERROR) { 641 // something happened! 642 recomputeVisibleRegions = true; 643 return outDirtyRegion; 644 } 645 646 // update the active buffer 647 mActiveBuffer = mSurfaceTexture->getCurrentBuffer(); 648 if (mActiveBuffer == NULL) { 649 // this can only happen if the very first buffer was rejected. 650 return outDirtyRegion; 651 } 652 653 mRefreshPending = true; 654 mFrameLatencyNeeded = true; 655 if (oldActiveBuffer == NULL) { 656 // the first time we receive a buffer, we need to trigger a 657 // geometry invalidation. 658 mFlinger->invalidateHwcGeometry(); 659 } 660 661 Rect crop(mSurfaceTexture->getCurrentCrop()); 662 const uint32_t transform(mSurfaceTexture->getCurrentTransform()); 663 const uint32_t scalingMode(mSurfaceTexture->getCurrentScalingMode()); 664 if ((crop != mCurrentCrop) || 665 (transform != mCurrentTransform) || 666 (scalingMode != mCurrentScalingMode)) 667 { 668 mCurrentCrop = crop; 669 mCurrentTransform = transform; 670 mCurrentScalingMode = scalingMode; 671 mFlinger->invalidateHwcGeometry(); 672 } 673 674 if (oldActiveBuffer != NULL) { 675 uint32_t bufWidth = mActiveBuffer->getWidth(); 676 uint32_t bufHeight = mActiveBuffer->getHeight(); 677 if (bufWidth != uint32_t(oldActiveBuffer->width) || 678 bufHeight != uint32_t(oldActiveBuffer->height)) { 679 mFlinger->invalidateHwcGeometry(); 680 } 681 } 682 683 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 684 if (oldOpacity != isOpaque()) { 685 recomputeVisibleRegions = true; 686 } 687 688 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 689 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 690 691 // FIXME: postedRegion should be dirty & bounds 692 const Layer::State& front(drawingState()); 693 Region dirtyRegion(Rect(front.active.w, front.active.h)); 694 695 // transform the dirty region to window-manager space 696 outDirtyRegion = (front.transform.transform(dirtyRegion)); 697 } 698 return outDirtyRegion; 699} 700 701void Layer::dump(String8& result, char* buffer, size_t SIZE) const 702{ 703 LayerBaseClient::dump(result, buffer, SIZE); 704 705 sp<const GraphicBuffer> buf0(mActiveBuffer); 706 uint32_t w0=0, h0=0, s0=0, f0=0; 707 if (buf0 != 0) { 708 w0 = buf0->getWidth(); 709 h0 = buf0->getHeight(); 710 s0 = buf0->getStride(); 711 f0 = buf0->format; 712 } 713 snprintf(buffer, SIZE, 714 " " 715 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 716 " queued-frames=%d, mRefreshPending=%d\n", 717 mFormat, w0, h0, s0,f0, 718 mQueuedFrames, mRefreshPending); 719 720 result.append(buffer); 721 722 if (mSurfaceTexture != 0) { 723 mSurfaceTexture->dump(result, " ", buffer, SIZE); 724 } 725} 726 727void Layer::dumpStats(String8& result, char* buffer, size_t SIZE) const 728{ 729 LayerBaseClient::dumpStats(result, buffer, SIZE); 730 const size_t o = mFrameLatencyOffset; 731 const nsecs_t period = 732 mFlinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 733 result.appendFormat("%lld\n", period); 734 for (size_t i=0 ; i<128 ; i++) { 735 const size_t index = (o+i) % 128; 736 const nsecs_t time_app = mFrameStats[index].timestamp; 737 const nsecs_t time_set = mFrameStats[index].set; 738 const nsecs_t time_vsync = mFrameStats[index].vsync; 739 result.appendFormat("%lld\t%lld\t%lld\n", 740 time_app, 741 time_vsync, 742 time_set); 743 } 744 result.append("\n"); 745} 746 747void Layer::clearStats() 748{ 749 LayerBaseClient::clearStats(); 750 memset(mFrameStats, 0, sizeof(mFrameStats)); 751} 752 753uint32_t Layer::getEffectiveUsage(uint32_t usage) const 754{ 755 // TODO: should we do something special if mSecure is set? 756 if (mProtectedByApp) { 757 // need a hardware-protected path to external video sink 758 usage |= GraphicBuffer::USAGE_PROTECTED; 759 } 760 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 761 return usage; 762} 763 764void Layer::updateTransformHint() const { 765 uint32_t orientation = 0; 766 if (!mFlinger->mDebugDisableTransformHint) { 767 // The transform hint is used to improve performance on the main 768 // display -- we can only have a single transform hint, it cannot 769 // apply to all displays. 770 // This is why we use the default display here. This is not an 771 // oversight. 772 sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); 773 const Transform& planeTransform(hw->getTransform()); 774 orientation = planeTransform.getOrientation(); 775 if (orientation & Transform::ROT_INVALID) { 776 orientation = 0; 777 } 778 } 779 mSurfaceTexture->setTransformHint(orientation); 780} 781 782// --------------------------------------------------------------------------- 783 784 785}; // namespace android 786