Layer.cpp revision d3ee231eddce0b69ec5e35188dbd0f4a2c3b9ac3
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, 54 DisplayID display, const sp<Client>& client) 55 : LayerBaseClient(flinger, display, client), 56 mTextureName(-1U), 57 mQueuedFrames(0), 58 mCurrentTransform(0), 59 mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), 60 mCurrentOpacity(true), 61 mRefreshPending(false), 62 mFrameLatencyNeeded(false), 63 mFrameLatencyOffset(0), 64 mFormat(PIXEL_FORMAT_NONE), 65 mGLExtensions(GLExtensions::getInstance()), 66 mOpaqueLayer(true), 67 mSecure(false), 68 mProtectedByApp(false) 69{ 70 mCurrentCrop.makeInvalid(); 71 glGenTextures(1, &mTextureName); 72} 73 74void Layer::onLayerDisplayed(const DisplayDevice& hw, 75 HWComposer::HWCLayerInterface* 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->setBufferCountServer(2); 109#else 110 mSurfaceTexture->setBufferCountServer(3); 111#endif 112} 113 114Layer::~Layer() 115{ 116 mFlinger->deleteTextureAsync(mTextureName); 117} 118 119void Layer::onFrameQueued() { 120 android_atomic_inc(&mQueuedFrames); 121 mFlinger->signalLayerUpdate(); 122} 123 124// called with SurfaceFlinger::mStateLock as soon as the layer is entered 125// in the purgatory list 126void Layer::onRemoved() 127{ 128 mSurfaceTexture->abandon(); 129} 130 131void Layer::setName(const String8& name) { 132 LayerBase::setName(name); 133 mSurfaceTexture->setName(name); 134} 135 136sp<ISurface> Layer::createSurface() 137{ 138 class BSurface : public BnSurface, public LayerCleaner { 139 wp<const Layer> mOwner; 140 virtual sp<ISurfaceTexture> getSurfaceTexture() const { 141 sp<ISurfaceTexture> res; 142 sp<const Layer> that( mOwner.promote() ); 143 if (that != NULL) { 144 res = that->mSurfaceTexture->getBufferQueue(); 145 } 146 return res; 147 } 148 public: 149 BSurface(const sp<SurfaceFlinger>& flinger, 150 const sp<Layer>& layer) 151 : LayerCleaner(flinger, layer), mOwner(layer) { } 152 }; 153 sp<ISurface> sur(new BSurface(mFlinger, this)); 154 return sur; 155} 156 157wp<IBinder> Layer::getSurfaceTextureBinder() const 158{ 159 return mSurfaceTexture->getBufferQueue()->asBinder(); 160} 161 162status_t Layer::setBuffers( uint32_t w, uint32_t h, 163 PixelFormat format, uint32_t flags) 164{ 165 // this surfaces pixel format 166 PixelFormatInfo info; 167 status_t err = getPixelFormatInfo(format, &info); 168 if (err) { 169 ALOGE("unsupported pixelformat %d", format); 170 return err; 171 } 172 173 uint32_t const maxSurfaceDims = min( 174 mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); 175 176 // never allow a surface larger than what our underlying GL implementation 177 // can handle. 178 if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) { 179 ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); 180 return BAD_VALUE; 181 } 182 183 mFormat = format; 184 185 mSecure = (flags & ISurfaceComposer::eSecure) ? true : false; 186 mProtectedByApp = (flags & ISurfaceComposer::eProtectedByApp) ? true : false; 187 mOpaqueLayer = (flags & ISurfaceComposer::eOpaque); 188 mCurrentOpacity = getOpacityForFormat(format); 189 190 mSurfaceTexture->setDefaultBufferSize(w, h); 191 mSurfaceTexture->setDefaultBufferFormat(format); 192 mSurfaceTexture->setConsumerUsageBits(getEffectiveUsage(0)); 193 194 return NO_ERROR; 195} 196 197Rect Layer::computeBufferCrop() const { 198 // Start with the SurfaceTexture's buffer crop... 199 Rect crop; 200 if (!mCurrentCrop.isEmpty()) { 201 crop = mCurrentCrop; 202 } else if (mActiveBuffer != NULL){ 203 crop = Rect(mActiveBuffer->getWidth(), mActiveBuffer->getHeight()); 204 } else { 205 crop.makeInvalid(); 206 return crop; 207 } 208 209 // ... then reduce that in the same proportions as the window crop reduces 210 // the window size. 211 const State& s(drawingState()); 212 if (!s.active.crop.isEmpty()) { 213 // Transform the window crop to match the buffer coordinate system, 214 // which means using the inverse of the current transform set on the 215 // SurfaceTexture. 216 uint32_t invTransform = mCurrentTransform; 217 int winWidth = s.active.w; 218 int winHeight = s.active.h; 219 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 220 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 221 NATIVE_WINDOW_TRANSFORM_FLIP_H; 222 winWidth = s.active.h; 223 winHeight = s.active.w; 224 } 225 Rect winCrop = s.active.crop.transform(invTransform, 226 s.active.w, s.active.h); 227 228 float xScale = float(crop.width()) / float(winWidth); 229 float yScale = float(crop.height()) / float(winHeight); 230 crop.left += int(ceilf(float(winCrop.left) * xScale)); 231 crop.top += int(ceilf(float(winCrop.top) * yScale)); 232 crop.right -= int(ceilf(float(winWidth - winCrop.right) * xScale)); 233 crop.bottom -= int(ceilf(float(winHeight - winCrop.bottom) * yScale)); 234 } 235 236 return crop; 237} 238 239void Layer::setGeometry( 240 const DisplayDevice& hw, 241 HWComposer::HWCLayerInterface& layer) 242{ 243 LayerBaseClient::setGeometry(hw, layer); 244 245 // enable this layer 246 layer.setSkip(false); 247 248 // we can't do alpha-fade with the hwc HAL 249 const State& s(drawingState()); 250 if (s.alpha < 0xFF) { 251 layer.setSkip(true); 252 } 253 254 /* 255 * Transformations are applied in this order: 256 * 1) buffer orientation/flip/mirror 257 * 2) state transformation (window manager) 258 * 3) layer orientation (screen orientation) 259 * (NOTE: the matrices are multiplied in reverse order) 260 */ 261 262 const Transform bufferOrientation(mCurrentTransform); 263 const Transform tr(hw.getTransform() * s.transform * bufferOrientation); 264 265 // this gives us only the "orientation" component of the transform 266 const uint32_t finalTransform = tr.getOrientation(); 267 268 // we can only handle simple transformation 269 if (finalTransform & Transform::ROT_INVALID) { 270 layer.setSkip(true); 271 } else { 272 layer.setTransform(finalTransform); 273 } 274 layer.setCrop(computeBufferCrop()); 275} 276 277void Layer::setPerFrameData(const DisplayDevice& hw, 278 HWComposer::HWCLayerInterface& layer) { 279 const sp<GraphicBuffer>& buffer(mActiveBuffer); 280 // NOTE: buffer can be NULL if the client never drew into this 281 // layer yet, or if we ran out of memory 282 layer.setBuffer(buffer); 283} 284 285void Layer::setAcquireFence(const DisplayDevice& hw, 286 HWComposer::HWCLayerInterface& layer) { 287 int fenceFd = -1; 288 289 // TODO: there is a possible optimization here: we only need to set the 290 // acquire fence the first time a new buffer is acquired on EACH display. 291 292 if (layer.getCompositionType() == HWC_OVERLAY) { 293 sp<Fence> fence = mSurfaceTexture->getCurrentFence(); 294 if (fence.get()) { 295 fenceFd = fence->dup(); 296 if (fenceFd == -1) { 297 ALOGW("failed to dup layer fence, skipping sync: %d", errno); 298 } 299 } 300 } 301 layer.setAcquireFenceFd(fenceFd); 302} 303 304void Layer::onDraw(const DisplayDevice& hw, const Region& clip) const 305{ 306 ATRACE_CALL(); 307 308 if (CC_UNLIKELY(mActiveBuffer == 0)) { 309 // the texture has not been created yet, this Layer has 310 // in fact never been drawn into. This happens frequently with 311 // SurfaceView because the WindowManager can't know when the client 312 // has drawn the first time. 313 314 // If there is nothing under us, we paint the screen in black, otherwise 315 // we just skip this update. 316 317 // figure out if there is something below us 318 Region under; 319 const SurfaceFlinger::LayerVector& drawingLayers( 320 mFlinger->mDrawingState.layersSortedByZ); 321 const size_t count = drawingLayers.size(); 322 for (size_t i=0 ; i<count ; ++i) { 323 const sp<LayerBase>& layer(drawingLayers[i]); 324 if (layer.get() == static_cast<LayerBase const*>(this)) 325 break; 326 under.orSelf( hw.getTransform().transform(layer->visibleRegion) ); 327 } 328 // if not everything below us is covered, we plug the holes! 329 Region holes(clip.subtract(under)); 330 if (!holes.isEmpty()) { 331 clearWithOpenGL(hw, holes, 0, 0, 0, 1); 332 } 333 return; 334 } 335 336 // TODO: replace this with a server-side wait 337 sp<Fence> fence = mSurfaceTexture->getCurrentFence(); 338 if (fence.get()) { 339 status_t err = fence->wait(Fence::TIMEOUT_NEVER); 340 ALOGW_IF(err != OK, "Layer::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), 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, 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(); 521 mFrameLatencyOffset = (mFrameLatencyOffset + 1) % 128; 522 mFrameLatencyNeeded = false; 523 } 524} 525 526Region Layer::latchBuffer(bool& recomputeVisibleRegions) 527{ 528 ATRACE_CALL(); 529 530 Region outDirtyRegion; 531 if (mQueuedFrames > 0) { 532 533 // if we've already called updateTexImage() without going through 534 // a composition step, we have to skip this layer at this point 535 // because we cannot call updateTeximage() without a corresponding 536 // compositionComplete() call. 537 // we'll trigger an update in onPreComposition(). 538 if (mRefreshPending) { 539 return outDirtyRegion; 540 } 541 542 // Capture the old state of the layer for comparisons later 543 const bool oldOpacity = isOpaque(); 544 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 545 546 // signal another event if we have more frames pending 547 if (android_atomic_dec(&mQueuedFrames) > 1) { 548 mFlinger->signalLayerUpdate(); 549 } 550 551 struct Reject : public SurfaceTexture::BufferRejecter { 552 Layer::State& front; 553 Layer::State& current; 554 bool& recomputeVisibleRegions; 555 Reject(Layer::State& front, Layer::State& current, 556 bool& recomputeVisibleRegions) 557 : front(front), current(current), 558 recomputeVisibleRegions(recomputeVisibleRegions) { 559 } 560 561 virtual bool reject(const sp<GraphicBuffer>& buf, 562 const BufferQueue::BufferItem& item) { 563 if (buf == NULL) { 564 return false; 565 } 566 567 uint32_t bufWidth = buf->getWidth(); 568 uint32_t bufHeight = buf->getHeight(); 569 570 // check that we received a buffer of the right size 571 // (Take the buffer's orientation into account) 572 if (item.mTransform & Transform::ROT_90) { 573 swap(bufWidth, bufHeight); 574 } 575 576 577 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 578 if (front.active != front.requested) { 579 580 if (isFixedSize || 581 (bufWidth == front.requested.w && 582 bufHeight == front.requested.h)) 583 { 584 // Here we pretend the transaction happened by updating the 585 // current and drawing states. Drawing state is only accessed 586 // in this thread, no need to have it locked 587 front.active = front.requested; 588 589 // We also need to update the current state so that 590 // we don't end-up overwriting the drawing state with 591 // this stale current state during the next transaction 592 // 593 // NOTE: We don't need to hold the transaction lock here 594 // because State::active is only accessed from this thread. 595 current.active = front.active; 596 597 // recompute visible region 598 recomputeVisibleRegions = true; 599 } 600 601 ALOGD_IF(DEBUG_RESIZE, 602 "lockPageFlip: (layer=%p), buffer (%ux%u, tr=%02x), scalingMode=%d\n" 603 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 604 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 605 this, bufWidth, bufHeight, item.mTransform, item.mScalingMode, 606 front.active.w, front.active.h, 607 front.active.crop.left, 608 front.active.crop.top, 609 front.active.crop.right, 610 front.active.crop.bottom, 611 front.active.crop.getWidth(), 612 front.active.crop.getHeight(), 613 front.requested.w, front.requested.h, 614 front.requested.crop.left, 615 front.requested.crop.top, 616 front.requested.crop.right, 617 front.requested.crop.bottom, 618 front.requested.crop.getWidth(), 619 front.requested.crop.getHeight()); 620 } 621 622 if (!isFixedSize) { 623 if (front.active.w != bufWidth || 624 front.active.h != bufHeight) { 625 // reject this buffer 626 return true; 627 } 628 } 629 return false; 630 } 631 }; 632 633 634 Reject r(mDrawingState, currentState(), recomputeVisibleRegions); 635 636 // XXX: not sure if setTransformHint belongs here 637 // it should only be needed when the main screen orientation changes 638 mSurfaceTexture->setTransformHint(getTransformHint()); 639 640 if (mSurfaceTexture->updateTexImage(&r) < 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 " transform-hint=0x%02x, queued-frames=%d, mRefreshPending=%d\n", 717 mFormat, w0, h0, s0,f0, 718 getTransformHint(), 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 DisplayDevice& hw(mFlinger->getDefaultDisplayDevice()); 732 const nsecs_t period = hw.getRefreshPeriod(); 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 764uint32_t Layer::getTransformHint() 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 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 return orientation; 780} 781 782// --------------------------------------------------------------------------- 783 784 785}; // namespace android 786