Layer.cpp revision 1df8c345854155cbbcb9f80de9d12d66ea70ac08
13192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz/* 23192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * Copyright (C) 2007 The Android Open Source Project 33192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * 43192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * Licensed under the Apache License, Version 2.0 (the "License"); 53192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * you may not use this file except in compliance with the License. 63192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * You may obtain a copy of the License at 73192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * 83192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * http://www.apache.org/licenses/LICENSE-2.0 93192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * 103192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * Unless required by applicable law or agreed to in writing, software 113192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * distributed under the License is distributed on an "AS IS" BASIS, 123192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 133192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * See the License for the specific language governing permissions and 143192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * limitations under the License. 153192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz */ 163192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 173192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#define ATRACE_TAG ATRACE_TAG_GRAPHICS 183192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 193192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <stdlib.h> 203192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <stdint.h> 213192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <sys/types.h> 223192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <math.h> 233192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 243192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <cutils/compiler.h> 253192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <cutils/native_handle.h> 263192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <cutils/properties.h> 273192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 283192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <utils/Errors.h> 293192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <utils/Log.h> 303192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <utils/StopWatch.h> 313192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <utils/Trace.h> 323192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 333192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <ui/GraphicBuffer.h> 343192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <ui/PixelFormat.h> 353192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 363192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include <gui/Surface.h> 373192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 383192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include "clz.h" 393192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include "DisplayDevice.h" 403192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include "GLExtensions.h" 413192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include "Layer.h" 423192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include "SurfaceFlinger.h" 433192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include "SurfaceTextureLayer.h" 443192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 453192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#include "DisplayHardware/HWComposer.h" 463192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 473192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#define DEBUG_RESIZE 0 483192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 493192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantznamespace android { 503192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 513192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz// --------------------------------------------------------------------------- 52287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell 533192633d4abe262d413e41feb871fe8deed409d8Jakob BornecrantzLayer::Layer(SurfaceFlinger* flinger, const sp<Client>& client) 543a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz : LayerBaseClient(flinger, client), 553192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mTextureName(-1U), 563192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mQueuedFrames(0), 57287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell mCurrentTransform(0), 58287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), 59287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell mCurrentOpacity(true), 60287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell mRefreshPending(false), 61287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell mFrameLatencyNeeded(false), 62287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell mFormat(PIXEL_FORMAT_NONE), 63287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell mGLExtensions(GLExtensions::getInstance()), 64e7843273fae516fa9922f12053bb6c063b39921cThomas Hellstrom mOpaqueLayer(true), 65e7843273fae516fa9922f12053bb6c063b39921cThomas Hellstrom mSecure(false), 663192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mProtectedByApp(false) 673192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz{ 683192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mCurrentCrop.makeInvalid(); 693192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz glGenTextures(1, &mTextureName); 703192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 713192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 723192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantzvoid Layer::onLayerDisplayed(const sp<const DisplayDevice>& hw, 733192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz HWComposer::HWCLayerInterface* layer) { 743192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz LayerBaseClient::onLayerDisplayed(hw, layer); 753192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz if (layer) { 763192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFenceFd()); 773192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } 783192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 793192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 803192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantzvoid Layer::onFirstRef() 813192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz{ 823192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz LayerBaseClient::onFirstRef(); 833192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 843192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // Creates a custom BufferQueue for SurfaceFlingerConsumer to use 853192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz sp<BufferQueue> bq = new SurfaceTextureLayer(); 867e28479c3af6a568d0421113b10f34f66f38d1d1José Fonseca mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(mTextureName, true, 873192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz GL_TEXTURE_EXTERNAL_OES, false, bq); 883192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 893192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 903192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mSurfaceFlingerConsumer->setFrameAvailableListener(this); 913192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mSurfaceFlingerConsumer->setSynchronousMode(true); 923192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 933192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#ifdef TARGET_DISABLE_TRIPLE_BUFFERING 943192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#warning "disabling triple buffering" 953192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mSurfaceFlingerConsumer->setDefaultMaxBufferCount(2); 963192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#else 973192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mSurfaceFlingerConsumer->setDefaultMaxBufferCount(3); 983192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz#endif 993192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1007e28479c3af6a568d0421113b10f34f66f38d1d1José Fonseca const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); 1013192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz updateTransformHint(hw); 1023192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 1033192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1043192633d4abe262d413e41feb871fe8deed409d8Jakob BornecrantzLayer::~Layer() 1053192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz{ 1063192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mFlinger->deleteTextureAsync(mTextureName); 1073192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 1083192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1093192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantzvoid Layer::onFrameAvailable() { 1103192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz android_atomic_inc(&mQueuedFrames); 1113192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mFlinger->signalLayerUpdate(); 1123192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 1133192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1143192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz// called with SurfaceFlinger::mStateLock as soon as the layer is entered 1153192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz// in the purgatory list 1163192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantzvoid Layer::onRemoved() 1173192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz{ 1183192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mSurfaceFlingerConsumer->abandon(); 1193192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 1203192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1213192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantzvoid Layer::setName(const String8& name) { 1223192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz LayerBase::setName(name); 1233192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mSurfaceFlingerConsumer->setName(name); 1243192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 1253192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1263192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantzsp<ISurface> Layer::createSurface() 1273192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz{ 1283192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz /* 1293192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * This class provides an implementation of BnSurface (the "native" or 1303192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * "remote" side of the Binder IPC interface ISurface), and mixes in 1313192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * LayerCleaner to ensure that mFlinger->onLayerDestroyed() is called for 1323192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * this layer when the BSurface is destroyed. 1333192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * 1343192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * The idea is to provide a handle to the Layer through ISurface that 1353192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * is cleaned up automatically when the last reference to the ISurface 1363192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * goes away. (The references will be held on the "proxy" side, while 137830827229141c08411c521f81283d1ad62f37163José Fonseca * the Layer exists on the "native" side.) 138830827229141c08411c521f81283d1ad62f37163José Fonseca * 139830827229141c08411c521f81283d1ad62f37163José Fonseca * The Layer has a reference to an instance of SurfaceFlinger's variant 1403192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * of GLConsumer, which holds a reference to the BufferQueue. The 1413192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * getSurfaceTexture() call returns a Binder interface reference for 1423192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * the producer interface of the buffer queue associated with the Layer. 1433192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz */ 1443192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz class BSurface : public BnSurface, public LayerCleaner { 1453192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz wp<const Layer> mOwner; 1463192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz virtual sp<IGraphicBufferProducer> getSurfaceTexture() const { 1473192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz sp<IGraphicBufferProducer> res; 1483192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz sp<const Layer> that( mOwner.promote() ); 1493192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz if (that != NULL) { 1503192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz res = that->mSurfaceFlingerConsumer->getBufferQueue(); 1513192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } 1523192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz return res; 1533192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } 1543192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz public: 1553192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz BSurface(const sp<SurfaceFlinger>& flinger, 1563192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz const sp<Layer>& layer) 1573192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz : LayerCleaner(flinger, layer), mOwner(layer) { } 1583192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz }; 1593192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz sp<ISurface> sur(new BSurface(mFlinger, this)); 1603192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz return sur; 1613192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 1623192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1633192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantzwp<IBinder> Layer::getSurfaceTextureBinder() const 1643192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz{ 1653192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz return mSurfaceFlingerConsumer->getBufferQueue()->asBinder(); 1663192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 1673192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1683192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantzstatus_t Layer::setBuffers( uint32_t w, uint32_t h, 1693192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz PixelFormat format, uint32_t flags) 1703192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz{ 1713192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // this surfaces pixel format 1723192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz PixelFormatInfo info; 1733192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz status_t err = getPixelFormatInfo(format, &info); 1743192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz if (err) { 1753192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz ALOGE("unsupported pixelformat %d", format); 1763192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz return err; 1773192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } 1783192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1793192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz uint32_t const maxSurfaceDims = min( 1803192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); 1813192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1823192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // never allow a surface larger than what our underlying GL implementation 1833192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // can handle. 1843192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) { 1853192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); 1863192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz return BAD_VALUE; 1873192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } 1883192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1893192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mFormat = format; 1903192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1913192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mSecure = (flags & ISurfaceComposerClient::eSecure) ? true : false; 1923192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; 1933192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mOpaqueLayer = (flags & ISurfaceComposerClient::eOpaque); 1943192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mCurrentOpacity = getOpacityForFormat(format); 1953192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 1963192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz mSurfaceFlingerConsumer->setDefaultBufferSize(w, h); 1973a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz mSurfaceFlingerConsumer->setDefaultBufferFormat(format); 198287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 1993a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz 2003a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz return NO_ERROR; 2013a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz} 2023a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz 2033a2358b6c64e028e170fef3254d54170fb2d14f1Jakob BornecrantzRect Layer::computeBufferCrop() const { 2043a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz // Start with the SurfaceFlingerConsumer's buffer crop... 2053a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz Rect crop; 2063a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz if (!mCurrentCrop.isEmpty()) { 207287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell crop = mCurrentCrop; 2083a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz } else if (mActiveBuffer != NULL){ 2093a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz crop = Rect(mActiveBuffer->getWidth(), mActiveBuffer->getHeight()); 2103a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz } else { 2113a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz crop.makeInvalid(); 2123a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz return crop; 2133a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz } 2143a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz 2153a2358b6c64e028e170fef3254d54170fb2d14f1Jakob Bornecrantz // ... then reduce that in the same proportions as the window crop reduces 2163192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // the window size. 2173192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz const State& s(drawingState()); 2183192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz if (!s.active.crop.isEmpty()) { 2193192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // Transform the window crop to match the buffer coordinate system, 2203192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // which means using the inverse of the current transform set on the 2213192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // SurfaceFlingerConsumer. 2223192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz uint32_t invTransform = mCurrentTransform; 2233192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz int winWidth = s.active.w; 2243192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz int winHeight = s.active.h; 2253192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 2263192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 2273192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz NATIVE_WINDOW_TRANSFORM_FLIP_H; 2283192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz winWidth = s.active.h; 2293192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz winHeight = s.active.w; 2303192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } 2313192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz Rect winCrop = s.active.crop.transform(invTransform, 2323192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz s.active.w, s.active.h); 2333192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2347e28479c3af6a568d0421113b10f34f66f38d1d1José Fonseca float xScale = float(crop.width()) / float(winWidth); 2353192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz float yScale = float(crop.height()) / float(winHeight); 2363192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz crop.left += int(ceilf(float(winCrop.left) * xScale)); 2373192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz crop.top += int(ceilf(float(winCrop.top) * yScale)); 2383192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz crop.right -= int(ceilf(float(winWidth - winCrop.right) * xScale)); 2393192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz crop.bottom -= int(ceilf(float(winHeight - winCrop.bottom) * yScale)); 2403192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } 2413192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2423192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz return crop; 2433192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 2443192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2453192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantzvoid Layer::setGeometry( 2463192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz const sp<const DisplayDevice>& hw, 247147ca90bd3fcac6dca28baf08ce7adb88821a414José Fonseca HWComposer::HWCLayerInterface& layer) 2483192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz{ 2493192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz LayerBaseClient::setGeometry(hw, layer); 2503192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2513192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // enable this layer 252147ca90bd3fcac6dca28baf08ce7adb88821a414José Fonseca layer.setSkip(false); 2533192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2543192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz if (isSecure() && !hw->isSecure()) { 2553192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz layer.setSkip(true); 2563192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } 2573192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2583192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz const State& s(drawingState()); 2593192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz layer.setPlaneAlpha(s.alpha); 2603192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2613192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz /* 2623192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * Transformations are applied in this order: 2633192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * 1) buffer orientation/flip/mirror 2643192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * 2) state transformation (window manager) 2653192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * 3) layer orientation (screen orientation) 2663192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz * (NOTE: the matrices are multiplied in reverse order) 2673192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz */ 2683192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2693192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz const Transform bufferOrientation(mCurrentTransform); 2703192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz const Transform tr(hw->getTransform() * s.transform * bufferOrientation); 2713192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2723192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // this gives us only the "orientation" component of the transform 2733192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz const uint32_t finalTransform = tr.getOrientation(); 2743192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2753192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // we can only handle simple transformation 2763192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz if (finalTransform & Transform::ROT_INVALID) { 2773192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz layer.setSkip(true); 2783192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } else { 2793192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz layer.setTransform(finalTransform); 2803192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } 2813192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz layer.setCrop(computeBufferCrop()); 2823192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 2833192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2843192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantzvoid Layer::setPerFrameData(const sp<const DisplayDevice>& hw, 2853192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz HWComposer::HWCLayerInterface& layer) { 2863192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz LayerBaseClient::setPerFrameData(hw, layer); 2873192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // NOTE: buffer can be NULL if the client never drew into this 2883192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz // layer yet, or if we ran out of memory 2893192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz layer.setBuffer(mActiveBuffer); 2903192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz} 2913192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz 2923192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantzvoid Layer::setAcquireFence(const sp<const DisplayDevice>& hw, 2933192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz HWComposer::HWCLayerInterface& layer) { 2943192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz int fenceFd = -1; 295cd151effe654c460c46ba55780eb89b3072077c0Thomas Hellstrom 296cd151effe654c460c46ba55780eb89b3072077c0Thomas Hellstrom // TODO: there is a possible optimization here: we only need to set the 297cd151effe654c460c46ba55780eb89b3072077c0Thomas Hellstrom // acquire fence the first time a new buffer is acquired on EACH display. 298287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell 2993192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz if (layer.getCompositionType() == HWC_OVERLAY) { 3003192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence(); 3013192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz if (fence->isValid()) { 3023192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz fenceFd = fence->dup(); 3033192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz if (fenceFd == -1) { 304287c94ea4987033f9c99a2f91c5750c9083504caKeith Whitwell ALOGW("failed to dup layer fence, skipping sync: %d", errno); 3053192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } 3063192633d4abe262d413e41feb871fe8deed409d8Jakob Bornecrantz } 307 } 308 layer.setAcquireFenceFd(fenceFd); 309} 310 311void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip) const 312{ 313 ATRACE_CALL(); 314 315 if (CC_UNLIKELY(mActiveBuffer == 0)) { 316 // the texture has not been created yet, this Layer has 317 // in fact never been drawn into. This happens frequently with 318 // SurfaceView because the WindowManager can't know when the client 319 // has drawn the first time. 320 321 // If there is nothing under us, we paint the screen in black, otherwise 322 // we just skip this update. 323 324 // figure out if there is something below us 325 Region under; 326 const SurfaceFlinger::LayerVector& drawingLayers( 327 mFlinger->mDrawingState.layersSortedByZ); 328 const size_t count = drawingLayers.size(); 329 for (size_t i=0 ; i<count ; ++i) { 330 const sp<LayerBase>& layer(drawingLayers[i]); 331 if (layer.get() == static_cast<LayerBase const*>(this)) 332 break; 333 under.orSelf( hw->getTransform().transform(layer->visibleRegion) ); 334 } 335 // if not everything below us is covered, we plug the holes! 336 Region holes(clip.subtract(under)); 337 if (!holes.isEmpty()) { 338 clearWithOpenGL(hw, holes, 0, 0, 0, 1); 339 } 340 return; 341 } 342 343 // Bind the current buffer to the GL texture, and wait for it to be 344 // ready for us to draw into. 345 status_t err = mSurfaceFlingerConsumer->bindTextureImage(); 346 if (err != NO_ERROR) { 347 ALOGW("onDraw: bindTextureImage failed (err=%d)", err); 348 // Go ahead and draw the buffer anyway; no matter what we do the screen 349 // is probably going to have something visibly wrong. 350 } 351 352 bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure()); 353 354 if (!blackOutLayer) { 355 // TODO: we could be more subtle with isFixedSize() 356 const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize(); 357 358 // Query the texture matrix given our current filtering mode. 359 float textureMatrix[16]; 360 mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering); 361 mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix); 362 363 // Set things up for texturing. 364 glBindTexture(GL_TEXTURE_EXTERNAL_OES, mTextureName); 365 GLenum filter = GL_NEAREST; 366 if (useFiltering) { 367 filter = GL_LINEAR; 368 } 369 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, filter); 370 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, filter); 371 glMatrixMode(GL_TEXTURE); 372 glLoadMatrixf(textureMatrix); 373 glMatrixMode(GL_MODELVIEW); 374 glDisable(GL_TEXTURE_2D); 375 glEnable(GL_TEXTURE_EXTERNAL_OES); 376 } else { 377 glBindTexture(GL_TEXTURE_2D, mFlinger->getProtectedTexName()); 378 glMatrixMode(GL_TEXTURE); 379 glLoadIdentity(); 380 glMatrixMode(GL_MODELVIEW); 381 glDisable(GL_TEXTURE_EXTERNAL_OES); 382 glEnable(GL_TEXTURE_2D); 383 } 384 385 drawWithOpenGL(hw, clip); 386 387 glDisable(GL_TEXTURE_EXTERNAL_OES); 388 glDisable(GL_TEXTURE_2D); 389} 390 391// As documented in libhardware header, formats in the range 392// 0x100 - 0x1FF are specific to the HAL implementation, and 393// are known to have no alpha channel 394// TODO: move definition for device-specific range into 395// hardware.h, instead of using hard-coded values here. 396#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) 397 398bool Layer::getOpacityForFormat(uint32_t format) 399{ 400 if (HARDWARE_IS_DEVICE_FORMAT(format)) { 401 return true; 402 } 403 PixelFormatInfo info; 404 status_t err = getPixelFormatInfo(PixelFormat(format), &info); 405 // in case of error (unknown format), we assume no blending 406 return (err || info.h_alpha <= info.l_alpha); 407} 408 409 410bool Layer::isOpaque() const 411{ 412 // if we don't have a buffer yet, we're translucent regardless of the 413 // layer's opaque flag. 414 if (mActiveBuffer == 0) { 415 return false; 416 } 417 418 // if the layer has the opaque flag, then we're always opaque, 419 // otherwise we use the current buffer's format. 420 return mOpaqueLayer || mCurrentOpacity; 421} 422 423bool Layer::isProtected() const 424{ 425 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 426 return (activeBuffer != 0) && 427 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 428} 429 430uint32_t Layer::doTransaction(uint32_t flags) 431{ 432 ATRACE_CALL(); 433 434 const Layer::State& front(drawingState()); 435 const Layer::State& temp(currentState()); 436 437 const bool sizeChanged = (temp.requested.w != front.requested.w) || 438 (temp.requested.h != front.requested.h); 439 440 if (sizeChanged) { 441 // the size changed, we need to ask our client to request a new buffer 442 ALOGD_IF(DEBUG_RESIZE, 443 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 444 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 445 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n" 446 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 447 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 448 this, (const char*) getName(), mCurrentTransform, mCurrentScalingMode, 449 temp.active.w, temp.active.h, 450 temp.active.crop.left, 451 temp.active.crop.top, 452 temp.active.crop.right, 453 temp.active.crop.bottom, 454 temp.active.crop.getWidth(), 455 temp.active.crop.getHeight(), 456 temp.requested.w, temp.requested.h, 457 temp.requested.crop.left, 458 temp.requested.crop.top, 459 temp.requested.crop.right, 460 temp.requested.crop.bottom, 461 temp.requested.crop.getWidth(), 462 temp.requested.crop.getHeight(), 463 front.active.w, front.active.h, 464 front.active.crop.left, 465 front.active.crop.top, 466 front.active.crop.right, 467 front.active.crop.bottom, 468 front.active.crop.getWidth(), 469 front.active.crop.getHeight(), 470 front.requested.w, front.requested.h, 471 front.requested.crop.left, 472 front.requested.crop.top, 473 front.requested.crop.right, 474 front.requested.crop.bottom, 475 front.requested.crop.getWidth(), 476 front.requested.crop.getHeight()); 477 478 // record the new size, form this point on, when the client request 479 // a buffer, it'll get the new size. 480 mSurfaceFlingerConsumer->setDefaultBufferSize( 481 temp.requested.w, temp.requested.h); 482 } 483 484 if (!isFixedSize()) { 485 486 const bool resizePending = (temp.requested.w != temp.active.w) || 487 (temp.requested.h != temp.active.h); 488 489 if (resizePending) { 490 // don't let LayerBase::doTransaction update the drawing state 491 // if we have a pending resize, unless we are in fixed-size mode. 492 // the drawing state will be updated only once we receive a buffer 493 // with the correct size. 494 // 495 // in particular, we want to make sure the clip (which is part 496 // of the geometry state) is latched together with the size but is 497 // latched immediately when no resizing is involved. 498 499 flags |= eDontUpdateGeometryState; 500 } 501 } 502 503 return LayerBase::doTransaction(flags); 504} 505 506bool Layer::isFixedSize() const { 507 return mCurrentScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 508} 509 510bool Layer::isCropped() const { 511 return !mCurrentCrop.isEmpty(); 512} 513 514// ---------------------------------------------------------------------------- 515// pageflip handling... 516// ---------------------------------------------------------------------------- 517 518bool Layer::onPreComposition() { 519 mRefreshPending = false; 520 return mQueuedFrames > 0; 521} 522 523void Layer::onPostComposition() { 524 if (mFrameLatencyNeeded) { 525 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 526 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 527 528 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence(); 529 if (frameReadyFence != NULL) { 530 mFrameTracker.setFrameReadyFence(frameReadyFence); 531 } else { 532 // There was no fence for this frame, so assume that it was ready 533 // to be presented at the desired present time. 534 mFrameTracker.setFrameReadyTime(desiredPresentTime); 535 } 536 537 const HWComposer& hwc = mFlinger->getHwComposer(); 538 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 539 if (presentFence != NULL) { 540 mFrameTracker.setActualPresentFence(presentFence); 541 } else { 542 // The HWC doesn't support present fences, so use the refresh 543 // timestamp instead. 544 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 545 mFrameTracker.setActualPresentTime(presentTime); 546 } 547 548 mFrameTracker.advanceFrame(); 549 mFrameLatencyNeeded = false; 550 } 551} 552 553bool Layer::isVisible() const { 554 return LayerBaseClient::isVisible() && (mActiveBuffer != NULL); 555} 556 557Region Layer::latchBuffer(bool& recomputeVisibleRegions) 558{ 559 ATRACE_CALL(); 560 561 Region outDirtyRegion; 562 if (mQueuedFrames > 0) { 563 564 // if we've already called updateTexImage() without going through 565 // a composition step, we have to skip this layer at this point 566 // because we cannot call updateTeximage() without a corresponding 567 // compositionComplete() call. 568 // we'll trigger an update in onPreComposition(). 569 if (mRefreshPending) { 570 return outDirtyRegion; 571 } 572 573 // Capture the old state of the layer for comparisons later 574 const bool oldOpacity = isOpaque(); 575 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 576 577 // signal another event if we have more frames pending 578 if (android_atomic_dec(&mQueuedFrames) > 1) { 579 mFlinger->signalLayerUpdate(); 580 } 581 582 struct Reject : public SurfaceFlingerConsumer::BufferRejecter { 583 Layer::State& front; 584 Layer::State& current; 585 bool& recomputeVisibleRegions; 586 Reject(Layer::State& front, Layer::State& current, 587 bool& recomputeVisibleRegions) 588 : front(front), current(current), 589 recomputeVisibleRegions(recomputeVisibleRegions) { 590 } 591 592 virtual bool reject(const sp<GraphicBuffer>& buf, 593 const BufferQueue::BufferItem& item) { 594 if (buf == NULL) { 595 return false; 596 } 597 598 uint32_t bufWidth = buf->getWidth(); 599 uint32_t bufHeight = buf->getHeight(); 600 601 // check that we received a buffer of the right size 602 // (Take the buffer's orientation into account) 603 if (item.mTransform & Transform::ROT_90) { 604 swap(bufWidth, bufHeight); 605 } 606 607 608 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE; 609 if (front.active != front.requested) { 610 611 if (isFixedSize || 612 (bufWidth == front.requested.w && 613 bufHeight == front.requested.h)) 614 { 615 // Here we pretend the transaction happened by updating the 616 // current and drawing states. Drawing state is only accessed 617 // in this thread, no need to have it locked 618 front.active = front.requested; 619 620 // We also need to update the current state so that 621 // we don't end-up overwriting the drawing state with 622 // this stale current state during the next transaction 623 // 624 // NOTE: We don't need to hold the transaction lock here 625 // because State::active is only accessed from this thread. 626 current.active = front.active; 627 628 // recompute visible region 629 recomputeVisibleRegions = true; 630 } 631 632 ALOGD_IF(DEBUG_RESIZE, 633 "latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n" 634 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 635 " requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n", 636 bufWidth, bufHeight, item.mTransform, item.mScalingMode, 637 front.active.w, front.active.h, 638 front.active.crop.left, 639 front.active.crop.top, 640 front.active.crop.right, 641 front.active.crop.bottom, 642 front.active.crop.getWidth(), 643 front.active.crop.getHeight(), 644 front.requested.w, front.requested.h, 645 front.requested.crop.left, 646 front.requested.crop.top, 647 front.requested.crop.right, 648 front.requested.crop.bottom, 649 front.requested.crop.getWidth(), 650 front.requested.crop.getHeight()); 651 } 652 653 if (!isFixedSize) { 654 if (front.active.w != bufWidth || 655 front.active.h != bufHeight) { 656 // reject this buffer 657 return true; 658 } 659 } 660 return false; 661 } 662 }; 663 664 665 Reject r(mDrawingState, currentState(), recomputeVisibleRegions); 666 667 if (mSurfaceFlingerConsumer->updateTexImage(&r) != NO_ERROR) { 668 // something happened! 669 recomputeVisibleRegions = true; 670 return outDirtyRegion; 671 } 672 673 // update the active buffer 674 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 675 if (mActiveBuffer == NULL) { 676 // this can only happen if the very first buffer was rejected. 677 return outDirtyRegion; 678 } 679 680 mRefreshPending = true; 681 mFrameLatencyNeeded = true; 682 if (oldActiveBuffer == NULL) { 683 // the first time we receive a buffer, we need to trigger a 684 // geometry invalidation. 685 recomputeVisibleRegions = true; 686 } 687 688 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 689 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 690 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 691 if ((crop != mCurrentCrop) || 692 (transform != mCurrentTransform) || 693 (scalingMode != mCurrentScalingMode)) 694 { 695 mCurrentCrop = crop; 696 mCurrentTransform = transform; 697 mCurrentScalingMode = scalingMode; 698 recomputeVisibleRegions = true; 699 } 700 701 if (oldActiveBuffer != NULL) { 702 uint32_t bufWidth = mActiveBuffer->getWidth(); 703 uint32_t bufHeight = mActiveBuffer->getHeight(); 704 if (bufWidth != uint32_t(oldActiveBuffer->width) || 705 bufHeight != uint32_t(oldActiveBuffer->height)) { 706 recomputeVisibleRegions = true; 707 } 708 } 709 710 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 711 if (oldOpacity != isOpaque()) { 712 recomputeVisibleRegions = true; 713 } 714 715 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 716 glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 717 718 // FIXME: postedRegion should be dirty & bounds 719 const Layer::State& front(drawingState()); 720 Region dirtyRegion(Rect(front.active.w, front.active.h)); 721 722 // transform the dirty region to window-manager space 723 outDirtyRegion = (front.transform.transform(dirtyRegion)); 724 } 725 return outDirtyRegion; 726} 727 728void Layer::dump(String8& result, char* buffer, size_t SIZE) const 729{ 730 LayerBaseClient::dump(result, buffer, SIZE); 731 732 sp<const GraphicBuffer> buf0(mActiveBuffer); 733 uint32_t w0=0, h0=0, s0=0, f0=0; 734 if (buf0 != 0) { 735 w0 = buf0->getWidth(); 736 h0 = buf0->getHeight(); 737 s0 = buf0->getStride(); 738 f0 = buf0->format; 739 } 740 snprintf(buffer, SIZE, 741 " " 742 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 743 " queued-frames=%d, mRefreshPending=%d\n", 744 mFormat, w0, h0, s0,f0, 745 mQueuedFrames, mRefreshPending); 746 747 result.append(buffer); 748 749 if (mSurfaceFlingerConsumer != 0) { 750 mSurfaceFlingerConsumer->dump(result, " ", buffer, SIZE); 751 } 752} 753 754void Layer::dumpStats(String8& result, char* buffer, size_t SIZE) const 755{ 756 LayerBaseClient::dumpStats(result, buffer, SIZE); 757 mFrameTracker.dump(result); 758} 759 760void Layer::clearStats() 761{ 762 LayerBaseClient::clearStats(); 763 mFrameTracker.clear(); 764} 765 766uint32_t Layer::getEffectiveUsage(uint32_t usage) const 767{ 768 // TODO: should we do something special if mSecure is set? 769 if (mProtectedByApp) { 770 // need a hardware-protected path to external video sink 771 usage |= GraphicBuffer::USAGE_PROTECTED; 772 } 773 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 774 return usage; 775} 776 777void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 778 uint32_t orientation = 0; 779 if (!mFlinger->mDebugDisableTransformHint) { 780 // The transform hint is used to improve performance, but we can 781 // only have a single transform hint, it cannot 782 // apply to all displays. 783 const Transform& planeTransform(hw->getTransform()); 784 orientation = planeTransform.getOrientation(); 785 if (orientation & Transform::ROT_INVALID) { 786 orientation = 0; 787 } 788 } 789 mSurfaceFlingerConsumer->setTransformHint(orientation); 790} 791 792// --------------------------------------------------------------------------- 793 794 795}; // namespace android 796