Layer.cpp revision de9ec44905aca4f0ef4f473065b0e7d93d7e1cfe
15698d4461a260dbf208484383f692b03c6473e74Ruben Brunk/* 25698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * Copyright (C) 2007 The Android Open Source Project 35698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * 45698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * Licensed under the Apache License, Version 2.0 (the "License"); 55698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * you may not use this file except in compliance with the License. 65698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * You may obtain a copy of the License at 75698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * 85698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * http://www.apache.org/licenses/LICENSE-2.0 95698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * 105698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * Unless required by applicable law or agreed to in writing, software 115698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * distributed under the License is distributed on an "AS IS" BASIS, 125698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 135698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * See the License for the specific language governing permissions and 145698d4461a260dbf208484383f692b03c6473e74Ruben Brunk * limitations under the License. 155698d4461a260dbf208484383f692b03c6473e74Ruben Brunk */ 165698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 175698d4461a260dbf208484383f692b03c6473e74Ruben Brunk//#define LOG_NDEBUG 0 185698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#undef LOG_TAG 195698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#define LOG_TAG "Layer" 205698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#define ATRACE_TAG ATRACE_TAG_GRAPHICS 216773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan 225698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <stdlib.h> 235698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <stdint.h> 245698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <sys/types.h> 255698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <math.h> 265698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 275698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <cutils/compiler.h> 285698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <cutils/native_handle.h> 295698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <cutils/properties.h> 305698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 315698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <utils/Errors.h> 325698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <utils/Log.h> 335698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <utils/NativeHandle.h> 345698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <utils/StopWatch.h> 355698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <utils/Trace.h> 365698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 375698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <ui/GraphicBuffer.h> 385698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <ui/PixelFormat.h> 395698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 405698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <gui/BufferItem.h> 415698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <gui/Surface.h> 425698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 435698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include "clz.h" 445698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include "Colorizer.h" 455698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include "DisplayDevice.h" 465698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include "Layer.h" 475698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include "LayerRejecter.h" 485698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include "MonitoredProducer.h" 495698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include "SurfaceFlinger.h" 505698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 515698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include "DisplayHardware/HWComposer.h" 525698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 535698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include "RenderEngine/RenderEngine.h" 545698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 555698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#include <mutex> 565698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 575698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#define DEBUG_RESIZE 0 585698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 595698d4461a260dbf208484383f692b03c6473e74Ruben Brunknamespace android { 605698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 615698d4461a260dbf208484383f692b03c6473e74Ruben Brunk// --------------------------------------------------------------------------- 625698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 635698d4461a260dbf208484383f692b03c6473e74Ruben Brunkint32_t Layer::sSequence = 1; 645698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 655698d4461a260dbf208484383f692b03c6473e74Ruben BrunkLayer::Layer(SurfaceFlinger* flinger, const sp<Client>& client, 665698d4461a260dbf208484383f692b03c6473e74Ruben Brunk const String8& name, uint32_t w, uint32_t h, uint32_t flags) 675698d4461a260dbf208484383f692b03c6473e74Ruben Brunk : contentDirty(false), 685698d4461a260dbf208484383f692b03c6473e74Ruben Brunk sequence(uint32_t(android_atomic_inc(&sSequence))), 695698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mFlinger(flinger), 705698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mTextureName(-1U), 715698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mPremultipliedAlpha(true), 725698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mName("unnamed"), 735698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mFormat(PIXEL_FORMAT_NONE), 745698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mTransactionFlags(0), 755698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mPendingStateMutex(), 765698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mPendingStates(), 77b3afa1e3c2af242e0d31a7619713b170d43c7e88Ruben Brunk mQueuedFrames(0), 78b3afa1e3c2af242e0d31a7619713b170d43c7e88Ruben Brunk mSidebandStreamChanged(false), 79b3afa1e3c2af242e0d31a7619713b170d43c7e88Ruben Brunk mCurrentTransform(0), 805698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), 815698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mOverrideScalingMode(-1), 820ccba97ebec0e0c5a20f8859ebac03d5fd14c97fEino-Ville Talvala mCurrentOpacity(true), 835698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mBufferLatched(false), 845698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mCurrentFrameNumber(0), 85b3afa1e3c2af242e0d31a7619713b170d43c7e88Ruben Brunk mPreviousFrameNumber(-1U), 860ccba97ebec0e0c5a20f8859ebac03d5fd14c97fEino-Ville Talvala mRefreshPending(false), 875698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mFrameLatencyNeeded(false), 885698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mFiltering(false), 89b3afa1e3c2af242e0d31a7619713b170d43c7e88Ruben Brunk mNeedsFiltering(false), 900ccba97ebec0e0c5a20f8859ebac03d5fd14c97fEino-Ville Talvala mMesh(Mesh::TRIANGLE_FAN, 4, 2, 2), 915698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#ifndef USE_HWC2 925698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mIsGlesComposition(false), 93b3afa1e3c2af242e0d31a7619713b170d43c7e88Ruben Brunk#endif 940ccba97ebec0e0c5a20f8859ebac03d5fd14c97fEino-Ville Talvala mProtectedByApp(false), 950ccba97ebec0e0c5a20f8859ebac03d5fd14c97fEino-Ville Talvala mHasSurface(false), 965698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mClientRef(client), 975698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mPotentialCursor(false), 985698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mQueueItemLock(), 995698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mQueueItemCondition(), 1005698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mQueueItems(), 1015698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mLastFrameNumberReceived(0), 1025698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mUpdateTexImageFailed(false), 1035698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mAutoRefresh(false), 1045698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mFreezePositionUpdates(false) 1055698d4461a260dbf208484383f692b03c6473e74Ruben Brunk{ 1065698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#ifdef USE_HWC2 1075698d4461a260dbf208484383f692b03c6473e74Ruben Brunk ALOGV("Creating Layer %s", name.string()); 1085698d4461a260dbf208484383f692b03c6473e74Ruben Brunk#endif 1095698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 1105698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mCurrentCrop.makeInvalid(); 1115698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mFlinger->getRenderEngine().genTextures(1, &mTextureName); 1125698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mTexture.init(Texture::TEXTURE_EXTERNAL, mTextureName); 1135698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 1145698d4461a260dbf208484383f692b03c6473e74Ruben Brunk uint32_t layerFlags = 0; 1155698d4461a260dbf208484383f692b03c6473e74Ruben Brunk if (flags & ISurfaceComposerClient::eHidden) 1165698d4461a260dbf208484383f692b03c6473e74Ruben Brunk layerFlags |= layer_state_t::eLayerHidden; 1175698d4461a260dbf208484383f692b03c6473e74Ruben Brunk if (flags & ISurfaceComposerClient::eOpaque) 1185698d4461a260dbf208484383f692b03c6473e74Ruben Brunk layerFlags |= layer_state_t::eLayerOpaque; 1195698d4461a260dbf208484383f692b03c6473e74Ruben Brunk if (flags & ISurfaceComposerClient::eSecure) 1205698d4461a260dbf208484383f692b03c6473e74Ruben Brunk layerFlags |= layer_state_t::eLayerSecure; 1215698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 1225698d4461a260dbf208484383f692b03c6473e74Ruben Brunk if (flags & ISurfaceComposerClient::eNonPremultiplied) 1235698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mPremultipliedAlpha = false; 1245698d4461a260dbf208484383f692b03c6473e74Ruben Brunk 1256773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan mName = name; 1266773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan 1276773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan mCurrentState.active.w = w; 1286773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan mCurrentState.active.h = h; 1296773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan mCurrentState.active.transform.set(0, 0); 1306773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan mCurrentState.crop.makeInvalid(); 1316773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan mCurrentState.finalCrop.makeInvalid(); 1326773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan mCurrentState.z = 0; 1336773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan#ifdef USE_HWC2 1346773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan mCurrentState.alpha = 1.0f; 1356773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan#else 1366773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan mCurrentState.alpha = 0xFF; 1376773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan#endif 1386773d4777f4ccbbe6377e4ae1b42c117066ae6baPraveen Chavan mCurrentState.layerStack = 0; 1395698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mCurrentState.flags = layerFlags; 1405698d4461a260dbf208484383f692b03c6473e74Ruben Brunk mCurrentState.sequence = 0; 141 mCurrentState.requested = mCurrentState.active; 142 mCurrentState.dataSpace = HAL_DATASPACE_UNKNOWN; 143 mCurrentState.appId = 0; 144 mCurrentState.type = 0; 145 146 // drawing state & current state are identical 147 mDrawingState = mCurrentState; 148 149#ifdef USE_HWC2 150 const auto& hwc = flinger->getHwComposer(); 151 const auto& activeConfig = hwc.getActiveConfig(HWC_DISPLAY_PRIMARY); 152 nsecs_t displayPeriod = activeConfig->getVsyncPeriod(); 153#else 154 nsecs_t displayPeriod = 155 flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 156#endif 157 mFrameTracker.setDisplayRefreshPeriod(displayPeriod); 158} 159 160void Layer::onFirstRef() { 161 // Creates a custom BufferQueue for SurfaceFlingerConsumer to use 162 sp<IGraphicBufferProducer> producer; 163 sp<IGraphicBufferConsumer> consumer; 164 BufferQueue::createBufferQueue(&producer, &consumer, nullptr, true); 165 mProducer = new MonitoredProducer(producer, mFlinger, this); 166 mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName, this); 167 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 168 mSurfaceFlingerConsumer->setContentsChangedListener(this); 169 mSurfaceFlingerConsumer->setName(mName); 170 171 if (mFlinger->isLayerTripleBufferingDisabled()) { 172 mProducer->setMaxDequeuedBufferCount(2); 173 } 174 175 const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); 176 updateTransformHint(hw); 177} 178 179Layer::~Layer() { 180 sp<Client> c(mClientRef.promote()); 181 if (c != 0) { 182 c->detachLayer(this); 183 } 184 185 for (auto& point : mRemoteSyncPoints) { 186 point->setTransactionApplied(); 187 } 188 for (auto& point : mLocalSyncPoints) { 189 point->setFrameAvailable(); 190 } 191 mFlinger->deleteTextureAsync(mTextureName); 192 mFrameTracker.logAndResetStats(mName); 193} 194 195// --------------------------------------------------------------------------- 196// callbacks 197// --------------------------------------------------------------------------- 198 199#ifdef USE_HWC2 200void Layer::onLayerDisplayed(const sp<Fence>& releaseFence) { 201 if (mHwcLayers.empty()) { 202 return; 203 } 204 mSurfaceFlingerConsumer->setReleaseFence(releaseFence); 205} 206#else 207void Layer::onLayerDisplayed(const sp<const DisplayDevice>& /* hw */, 208 HWComposer::HWCLayerInterface* layer) { 209 if (layer) { 210 layer->onDisplayed(); 211 mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFence()); 212 } 213} 214#endif 215 216void Layer::onFrameAvailable(const BufferItem& item) { 217 // Add this buffer from our internal queue tracker 218 { // Autolock scope 219 Mutex::Autolock lock(mQueueItemLock); 220 mFlinger->mInterceptor.saveBufferUpdate(this, item.mGraphicBuffer->getWidth(), 221 item.mGraphicBuffer->getHeight(), item.mFrameNumber); 222 // Reset the frame number tracker when we receive the first buffer after 223 // a frame number reset 224 if (item.mFrameNumber == 1) { 225 mLastFrameNumberReceived = 0; 226 } 227 228 // Ensure that callbacks are handled in order 229 while (item.mFrameNumber != mLastFrameNumberReceived + 1) { 230 status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, 231 ms2ns(500)); 232 if (result != NO_ERROR) { 233 ALOGE("[%s] Timed out waiting on callback", mName.string()); 234 } 235 } 236 237 mQueueItems.push_back(item); 238 android_atomic_inc(&mQueuedFrames); 239 240 // Wake up any pending callbacks 241 mLastFrameNumberReceived = item.mFrameNumber; 242 mQueueItemCondition.broadcast(); 243 } 244 245 mFlinger->signalLayerUpdate(); 246} 247 248void Layer::onFrameReplaced(const BufferItem& item) { 249 { // Autolock scope 250 Mutex::Autolock lock(mQueueItemLock); 251 252 // Ensure that callbacks are handled in order 253 while (item.mFrameNumber != mLastFrameNumberReceived + 1) { 254 status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, 255 ms2ns(500)); 256 if (result != NO_ERROR) { 257 ALOGE("[%s] Timed out waiting on callback", mName.string()); 258 } 259 } 260 261 if (mQueueItems.empty()) { 262 ALOGE("Can't replace a frame on an empty queue"); 263 return; 264 } 265 mQueueItems.editItemAt(mQueueItems.size() - 1) = item; 266 267 // Wake up any pending callbacks 268 mLastFrameNumberReceived = item.mFrameNumber; 269 mQueueItemCondition.broadcast(); 270 } 271} 272 273void Layer::onSidebandStreamChanged() { 274 if (android_atomic_release_cas(false, true, &mSidebandStreamChanged) == 0) { 275 // mSidebandStreamChanged was false 276 mFlinger->signalLayerUpdate(); 277 } 278} 279 280// called with SurfaceFlinger::mStateLock from the drawing thread after 281// the layer has been remove from the current state list (and just before 282// it's removed from the drawing state list) 283void Layer::onRemoved() { 284 mSurfaceFlingerConsumer->abandon(); 285 for (const auto& child : mCurrentChildren) { 286 child->onRemoved(); 287 } 288} 289 290// --------------------------------------------------------------------------- 291// set-up 292// --------------------------------------------------------------------------- 293 294const String8& Layer::getName() const { 295 return mName; 296} 297 298status_t Layer::setBuffers( uint32_t w, uint32_t h, 299 PixelFormat format, uint32_t flags) 300{ 301 uint32_t const maxSurfaceDims = min( 302 mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); 303 304 // never allow a surface larger than what our underlying GL implementation 305 // can handle. 306 if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) { 307 ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); 308 return BAD_VALUE; 309 } 310 311 mFormat = format; 312 313 mPotentialCursor = (flags & ISurfaceComposerClient::eCursorWindow) ? true : false; 314 mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; 315 mCurrentOpacity = getOpacityForFormat(format); 316 317 mSurfaceFlingerConsumer->setDefaultBufferSize(w, h); 318 mSurfaceFlingerConsumer->setDefaultBufferFormat(format); 319 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0)); 320 321 return NO_ERROR; 322} 323 324sp<IBinder> Layer::getHandle() { 325 Mutex::Autolock _l(mLock); 326 327 LOG_ALWAYS_FATAL_IF(mHasSurface, 328 "Layer::getHandle() has already been called"); 329 330 mHasSurface = true; 331 332 return new Handle(mFlinger, this); 333} 334 335sp<IGraphicBufferProducer> Layer::getProducer() const { 336 return mProducer; 337} 338 339// --------------------------------------------------------------------------- 340// h/w composer set-up 341// --------------------------------------------------------------------------- 342 343Rect Layer::getContentCrop() const { 344 // this is the crop rectangle that applies to the buffer 345 // itself (as opposed to the window) 346 Rect crop; 347 if (!mCurrentCrop.isEmpty()) { 348 // if the buffer crop is defined, we use that 349 crop = mCurrentCrop; 350 } else if (mActiveBuffer != NULL) { 351 // otherwise we use the whole buffer 352 crop = mActiveBuffer->getBounds(); 353 } else { 354 // if we don't have a buffer yet, we use an empty/invalid crop 355 crop.makeInvalid(); 356 } 357 return crop; 358} 359 360static Rect reduce(const Rect& win, const Region& exclude) { 361 if (CC_LIKELY(exclude.isEmpty())) { 362 return win; 363 } 364 if (exclude.isRect()) { 365 return win.reduce(exclude.getBounds()); 366 } 367 return Region(win).subtract(exclude).getBounds(); 368} 369 370Rect Layer::computeScreenBounds(bool reduceTransparentRegion) const { 371 const Layer::State& s(getDrawingState()); 372 Rect win(s.active.w, s.active.h); 373 374 if (!s.crop.isEmpty()) { 375 win.intersect(s.crop, &win); 376 } 377 378 Transform t = getTransform(); 379 win = t.transform(win); 380 381 const sp<Layer>& p = getParent(); 382 // Now we need to calculate the parent bounds, so we can clip ourselves to those. 383 // When calculating the parent bounds for purposes of clipping, 384 // we don't need to constrain the parent to its transparent region. 385 // The transparent region is an optimization based on the 386 // buffer contents of the layer, but does not affect the space allocated to 387 // it by policy, and thus children should be allowed to extend into the 388 // parent's transparent region. In fact one of the main uses, is to reduce 389 // buffer allocation size in cases where a child window sits behind a main window 390 // (by marking the hole in the parent window as a transparent region) 391 if (p != nullptr) { 392 Rect bounds = p->computeScreenBounds(false); 393 bounds.intersect(win, &win); 394 } 395 396 if (reduceTransparentRegion) { 397 auto const screenTransparentRegion = t.transform(s.activeTransparentRegion); 398 win = reduce(win, screenTransparentRegion); 399 } 400 401 return win; 402} 403 404Rect Layer::computeBounds() const { 405 const Layer::State& s(getDrawingState()); 406 return computeBounds(s.activeTransparentRegion); 407} 408 409Rect Layer::computeBounds(const Region& activeTransparentRegion) const { 410 const Layer::State& s(getDrawingState()); 411 Rect win(s.active.w, s.active.h); 412 413 if (!s.crop.isEmpty()) { 414 win.intersect(s.crop, &win); 415 } 416 417 Rect bounds = win; 418 const auto& p = getParent(); 419 if (p != nullptr) { 420 // Look in computeScreenBounds recursive call for explanation of 421 // why we pass false here. 422 bounds = p->computeScreenBounds(false /* reduceTransparentRegion */); 423 } 424 425 Transform t = getTransform(); 426 if (p != nullptr) { 427 win = t.transform(win); 428 win.intersect(bounds, &win); 429 win = t.inverse().transform(win); 430 } 431 432 // subtract the transparent region and snap to the bounds 433 return reduce(win, activeTransparentRegion); 434} 435 436Rect Layer::computeInitialCrop(const sp<const DisplayDevice>& hw) const { 437 // the crop is the area of the window that gets cropped, but not 438 // scaled in any ways. 439 const State& s(getDrawingState()); 440 441 // apply the projection's clipping to the window crop in 442 // layerstack space, and convert-back to layer space. 443 // if there are no window scaling involved, this operation will map to full 444 // pixels in the buffer. 445 // FIXME: the 3 lines below can produce slightly incorrect clipping when we have 446 // a viewport clipping and a window transform. we should use floating point to fix this. 447 448 Rect activeCrop(s.active.w, s.active.h); 449 if (!s.crop.isEmpty()) { 450 activeCrop = s.crop; 451 } 452 453 Transform t = getTransform(); 454 activeCrop = t.transform(activeCrop); 455 if (!activeCrop.intersect(hw->getViewport(), &activeCrop)) { 456 activeCrop.clear(); 457 } 458 if (!s.finalCrop.isEmpty()) { 459 if(!activeCrop.intersect(s.finalCrop, &activeCrop)) { 460 activeCrop.clear(); 461 } 462 } 463 return activeCrop; 464} 465 466gfx::FloatRect Layer::computeCrop(const sp<const DisplayDevice>& hw) const { 467 // the content crop is the area of the content that gets scaled to the 468 // layer's size. This is in buffer space. 469 gfx::FloatRect crop = getContentCrop().toFloatRect(); 470 471 // In addition there is a WM-specified crop we pull from our drawing state. 472 const State& s(getDrawingState()); 473 474 // Screen space to make reduction to parent crop clearer. 475 Rect activeCrop = computeInitialCrop(hw); 476 const auto& p = getParent(); 477 if (p != nullptr) { 478 auto parentCrop = p->computeInitialCrop(hw); 479 activeCrop.intersect(parentCrop, &activeCrop); 480 } 481 Transform t = getTransform(); 482 // Back to layer space to work with the content crop. 483 activeCrop = t.inverse().transform(activeCrop); 484 485 // This needs to be here as transform.transform(Rect) computes the 486 // transformed rect and then takes the bounding box of the result before 487 // returning. This means 488 // transform.inverse().transform(transform.transform(Rect)) != Rect 489 // in which case we need to make sure the final rect is clipped to the 490 // display bounds. 491 if (!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) { 492 activeCrop.clear(); 493 } 494 495 // subtract the transparent region and snap to the bounds 496 activeCrop = reduce(activeCrop, s.activeTransparentRegion); 497 498 // Transform the window crop to match the buffer coordinate system, 499 // which means using the inverse of the current transform set on the 500 // SurfaceFlingerConsumer. 501 uint32_t invTransform = mCurrentTransform; 502 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { 503 /* 504 * the code below applies the primary display's inverse transform to the 505 * buffer 506 */ 507 uint32_t invTransformOrient = 508 DisplayDevice::getPrimaryDisplayOrientationTransform(); 509 // calculate the inverse transform 510 if (invTransformOrient & NATIVE_WINDOW_TRANSFORM_ROT_90) { 511 invTransformOrient ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 512 NATIVE_WINDOW_TRANSFORM_FLIP_H; 513 } 514 // and apply to the current transform 515 invTransform = (Transform(invTransformOrient) * Transform(invTransform)) 516 .getOrientation(); 517 } 518 519 int winWidth = s.active.w; 520 int winHeight = s.active.h; 521 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 522 // If the activeCrop has been rotate the ends are rotated but not 523 // the space itself so when transforming ends back we can't rely on 524 // a modification of the axes of rotation. To account for this we 525 // need to reorient the inverse rotation in terms of the current 526 // axes of rotation. 527 bool is_h_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0; 528 bool is_v_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0; 529 if (is_h_flipped == is_v_flipped) { 530 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 531 NATIVE_WINDOW_TRANSFORM_FLIP_H; 532 } 533 winWidth = s.active.h; 534 winHeight = s.active.w; 535 } 536 const Rect winCrop = activeCrop.transform( 537 invTransform, s.active.w, s.active.h); 538 539 // below, crop is intersected with winCrop expressed in crop's coordinate space 540 float xScale = crop.getWidth() / float(winWidth); 541 float yScale = crop.getHeight() / float(winHeight); 542 543 float insetL = winCrop.left * xScale; 544 float insetT = winCrop.top * yScale; 545 float insetR = (winWidth - winCrop.right ) * xScale; 546 float insetB = (winHeight - winCrop.bottom) * yScale; 547 548 crop.left += insetL; 549 crop.top += insetT; 550 crop.right -= insetR; 551 crop.bottom -= insetB; 552 553 return crop; 554} 555 556#ifdef USE_HWC2 557void Layer::setGeometry(const sp<const DisplayDevice>& displayDevice, uint32_t z) 558#else 559void Layer::setGeometry( 560 const sp<const DisplayDevice>& hw, 561 HWComposer::HWCLayerInterface& layer) 562#endif 563{ 564#ifdef USE_HWC2 565 const auto hwcId = displayDevice->getHwcDisplayId(); 566 auto& hwcInfo = mHwcLayers[hwcId]; 567#else 568 layer.setDefaultState(); 569#endif 570 571 // enable this layer 572#ifdef USE_HWC2 573 hwcInfo.forceClientComposition = false; 574 575 if (isSecure() && !displayDevice->isSecure()) { 576 hwcInfo.forceClientComposition = true; 577 } 578 579 auto& hwcLayer = hwcInfo.layer; 580#else 581 layer.setSkip(false); 582 583 if (isSecure() && !hw->isSecure()) { 584 layer.setSkip(true); 585 } 586#endif 587 588 // this gives us only the "orientation" component of the transform 589 const State& s(getDrawingState()); 590#ifdef USE_HWC2 591 if (!isOpaque(s) || s.alpha != 1.0f) { 592 auto blendMode = mPremultipliedAlpha ? 593 HWC2::BlendMode::Premultiplied : HWC2::BlendMode::Coverage; 594 auto error = hwcLayer->setBlendMode(blendMode); 595 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set blend mode %s:" 596 " %s (%d)", mName.string(), to_string(blendMode).c_str(), 597 to_string(error).c_str(), static_cast<int32_t>(error)); 598 } 599#else 600 if (!isOpaque(s) || s.alpha != 0xFF) { 601 layer.setBlending(mPremultipliedAlpha ? 602 HWC_BLENDING_PREMULT : 603 HWC_BLENDING_COVERAGE); 604 } 605#endif 606 607 // apply the layer's transform, followed by the display's global transform 608 // here we're guaranteed that the layer's transform preserves rects 609 Region activeTransparentRegion(s.activeTransparentRegion); 610 Transform t = getTransform(); 611 if (!s.crop.isEmpty()) { 612 Rect activeCrop(s.crop); 613 activeCrop = t.transform(activeCrop); 614#ifdef USE_HWC2 615 if(!activeCrop.intersect(displayDevice->getViewport(), &activeCrop)) { 616#else 617 if(!activeCrop.intersect(hw->getViewport(), &activeCrop)) { 618#endif 619 activeCrop.clear(); 620 } 621 activeCrop = t.inverse().transform(activeCrop, true); 622 // This needs to be here as transform.transform(Rect) computes the 623 // transformed rect and then takes the bounding box of the result before 624 // returning. This means 625 // transform.inverse().transform(transform.transform(Rect)) != Rect 626 // in which case we need to make sure the final rect is clipped to the 627 // display bounds. 628 if(!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) { 629 activeCrop.clear(); 630 } 631 // mark regions outside the crop as transparent 632 activeTransparentRegion.orSelf(Rect(0, 0, s.active.w, activeCrop.top)); 633 activeTransparentRegion.orSelf(Rect(0, activeCrop.bottom, 634 s.active.w, s.active.h)); 635 activeTransparentRegion.orSelf(Rect(0, activeCrop.top, 636 activeCrop.left, activeCrop.bottom)); 637 activeTransparentRegion.orSelf(Rect(activeCrop.right, activeCrop.top, 638 s.active.w, activeCrop.bottom)); 639 } 640 641 Rect frame(t.transform(computeBounds(activeTransparentRegion))); 642 if (!s.finalCrop.isEmpty()) { 643 if(!frame.intersect(s.finalCrop, &frame)) { 644 frame.clear(); 645 } 646 } 647#ifdef USE_HWC2 648 if (!frame.intersect(displayDevice->getViewport(), &frame)) { 649 frame.clear(); 650 } 651 const Transform& tr(displayDevice->getTransform()); 652 Rect transformedFrame = tr.transform(frame); 653 auto error = hwcLayer->setDisplayFrame(transformedFrame); 654 if (error != HWC2::Error::None) { 655 ALOGE("[%s] Failed to set display frame [%d, %d, %d, %d]: %s (%d)", 656 mName.string(), transformedFrame.left, transformedFrame.top, 657 transformedFrame.right, transformedFrame.bottom, 658 to_string(error).c_str(), static_cast<int32_t>(error)); 659 } else { 660 hwcInfo.displayFrame = transformedFrame; 661 } 662 663 gfx::FloatRect sourceCrop = computeCrop(displayDevice); 664 error = hwcLayer->setSourceCrop(sourceCrop); 665 if (error != HWC2::Error::None) { 666 ALOGE("[%s] Failed to set source crop [%.3f, %.3f, %.3f, %.3f]: " 667 "%s (%d)", mName.string(), sourceCrop.left, sourceCrop.top, 668 sourceCrop.right, sourceCrop.bottom, to_string(error).c_str(), 669 static_cast<int32_t>(error)); 670 } else { 671 hwcInfo.sourceCrop = sourceCrop; 672 } 673 674 error = hwcLayer->setPlaneAlpha(s.alpha); 675 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set plane alpha %.3f: " 676 "%s (%d)", mName.string(), s.alpha, to_string(error).c_str(), 677 static_cast<int32_t>(error)); 678 679 error = hwcLayer->setZOrder(z); 680 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set Z %u: %s (%d)", 681 mName.string(), z, to_string(error).c_str(), 682 static_cast<int32_t>(error)); 683 684 error = hwcLayer->setInfo(s.type, s.appId); 685 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set info (%d)", 686 mName.string(), static_cast<int32_t>(error)); 687#else 688 if (!frame.intersect(hw->getViewport(), &frame)) { 689 frame.clear(); 690 } 691 const Transform& tr(hw->getTransform()); 692 layer.setFrame(tr.transform(frame)); 693 layer.setCrop(computeCrop(hw)); 694 layer.setPlaneAlpha(s.alpha); 695#endif 696 697 /* 698 * Transformations are applied in this order: 699 * 1) buffer orientation/flip/mirror 700 * 2) state transformation (window manager) 701 * 3) layer orientation (screen orientation) 702 * (NOTE: the matrices are multiplied in reverse order) 703 */ 704 705 const Transform bufferOrientation(mCurrentTransform); 706 Transform transform(tr * t * bufferOrientation); 707 708 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { 709 /* 710 * the code below applies the primary display's inverse transform to the 711 * buffer 712 */ 713 uint32_t invTransform = 714 DisplayDevice::getPrimaryDisplayOrientationTransform(); 715 // calculate the inverse transform 716 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) { 717 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | 718 NATIVE_WINDOW_TRANSFORM_FLIP_H; 719 } 720 // and apply to the current transform 721 transform = Transform(invTransform) * transform; 722 } 723 724 // this gives us only the "orientation" component of the transform 725 const uint32_t orientation = transform.getOrientation(); 726#ifdef USE_HWC2 727 if (orientation & Transform::ROT_INVALID) { 728 // we can only handle simple transformation 729 hwcInfo.forceClientComposition = true; 730 } else { 731 auto transform = static_cast<HWC2::Transform>(orientation); 732 auto error = hwcLayer->setTransform(transform); 733 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set transform %s: " 734 "%s (%d)", mName.string(), to_string(transform).c_str(), 735 to_string(error).c_str(), static_cast<int32_t>(error)); 736 } 737#else 738 if (orientation & Transform::ROT_INVALID) { 739 // we can only handle simple transformation 740 layer.setSkip(true); 741 } else { 742 layer.setTransform(orientation); 743 } 744#endif 745} 746 747#ifdef USE_HWC2 748void Layer::forceClientComposition(int32_t hwcId) { 749 if (mHwcLayers.count(hwcId) == 0) { 750 ALOGE("forceClientComposition: no HWC layer found (%d)", hwcId); 751 return; 752 } 753 754 mHwcLayers[hwcId].forceClientComposition = true; 755} 756#endif 757 758#ifdef USE_HWC2 759void Layer::setPerFrameData(const sp<const DisplayDevice>& displayDevice) { 760 // Apply this display's projection's viewport to the visible region 761 // before giving it to the HWC HAL. 762 const Transform& tr = displayDevice->getTransform(); 763 const auto& viewport = displayDevice->getViewport(); 764 Region visible = tr.transform(visibleRegion.intersect(viewport)); 765 auto hwcId = displayDevice->getHwcDisplayId(); 766 auto& hwcLayer = mHwcLayers[hwcId].layer; 767 auto error = hwcLayer->setVisibleRegion(visible); 768 if (error != HWC2::Error::None) { 769 ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(), 770 to_string(error).c_str(), static_cast<int32_t>(error)); 771 visible.dump(LOG_TAG); 772 } 773 774 error = hwcLayer->setSurfaceDamage(surfaceDamageRegion); 775 if (error != HWC2::Error::None) { 776 ALOGE("[%s] Failed to set surface damage: %s (%d)", mName.string(), 777 to_string(error).c_str(), static_cast<int32_t>(error)); 778 surfaceDamageRegion.dump(LOG_TAG); 779 } 780 781 // Sideband layers 782 if (mSidebandStream.get()) { 783 setCompositionType(hwcId, HWC2::Composition::Sideband); 784 ALOGV("[%s] Requesting Sideband composition", mName.string()); 785 error = hwcLayer->setSidebandStream(mSidebandStream->handle()); 786 if (error != HWC2::Error::None) { 787 ALOGE("[%s] Failed to set sideband stream %p: %s (%d)", 788 mName.string(), mSidebandStream->handle(), 789 to_string(error).c_str(), static_cast<int32_t>(error)); 790 } 791 return; 792 } 793 794 // Client layers 795 if (mHwcLayers[hwcId].forceClientComposition || 796 (mActiveBuffer != nullptr && mActiveBuffer->handle == nullptr)) { 797 ALOGV("[%s] Requesting Client composition", mName.string()); 798 setCompositionType(hwcId, HWC2::Composition::Client); 799 return; 800 } 801 802 // SolidColor layers 803 if (mActiveBuffer == nullptr) { 804 setCompositionType(hwcId, HWC2::Composition::SolidColor); 805 806 // For now, we only support black for DimLayer 807 error = hwcLayer->setColor({0, 0, 0, 255}); 808 if (error != HWC2::Error::None) { 809 ALOGE("[%s] Failed to set color: %s (%d)", mName.string(), 810 to_string(error).c_str(), static_cast<int32_t>(error)); 811 } 812 813 // Clear out the transform, because it doesn't make sense absent a 814 // source buffer 815 error = hwcLayer->setTransform(HWC2::Transform::None); 816 if (error != HWC2::Error::None) { 817 ALOGE("[%s] Failed to clear transform: %s (%d)", mName.string(), 818 to_string(error).c_str(), static_cast<int32_t>(error)); 819 } 820 821 return; 822 } 823 824 // Device or Cursor layers 825 if (mPotentialCursor) { 826 ALOGV("[%s] Requesting Cursor composition", mName.string()); 827 setCompositionType(hwcId, HWC2::Composition::Cursor); 828 } else { 829 ALOGV("[%s] Requesting Device composition", mName.string()); 830 setCompositionType(hwcId, HWC2::Composition::Device); 831 } 832 833 ALOGV("setPerFrameData: dataspace = %d", mCurrentState.dataSpace); 834 error = hwcLayer->setDataspace(mCurrentState.dataSpace); 835 if (error != HWC2::Error::None) { 836 ALOGE("[%s] Failed to set dataspace %d: %s (%d)", mName.string(), 837 mCurrentState.dataSpace, to_string(error).c_str(), 838 static_cast<int32_t>(error)); 839 } 840 841 auto acquireFence = mSurfaceFlingerConsumer->getCurrentFence(); 842 error = hwcLayer->setBuffer(mActiveBuffer->handle, acquireFence); 843 if (error != HWC2::Error::None) { 844 ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(), 845 mActiveBuffer->handle, to_string(error).c_str(), 846 static_cast<int32_t>(error)); 847 } 848} 849#else 850void Layer::setPerFrameData(const sp<const DisplayDevice>& hw, 851 HWComposer::HWCLayerInterface& layer) { 852 // we have to set the visible region on every frame because 853 // we currently free it during onLayerDisplayed(), which is called 854 // after HWComposer::commit() -- every frame. 855 // Apply this display's projection's viewport to the visible region 856 // before giving it to the HWC HAL. 857 const Transform& tr = hw->getTransform(); 858 Region visible = tr.transform(visibleRegion.intersect(hw->getViewport())); 859 layer.setVisibleRegionScreen(visible); 860 layer.setSurfaceDamage(surfaceDamageRegion); 861 mIsGlesComposition = (layer.getCompositionType() == HWC_FRAMEBUFFER); 862 863 if (mSidebandStream.get()) { 864 layer.setSidebandStream(mSidebandStream); 865 } else { 866 // NOTE: buffer can be NULL if the client never drew into this 867 // layer yet, or if we ran out of memory 868 layer.setBuffer(mActiveBuffer); 869 } 870} 871#endif 872 873#ifdef USE_HWC2 874void Layer::updateCursorPosition(const sp<const DisplayDevice>& displayDevice) { 875 auto hwcId = displayDevice->getHwcDisplayId(); 876 if (mHwcLayers.count(hwcId) == 0 || 877 getCompositionType(hwcId) != HWC2::Composition::Cursor) { 878 return; 879 } 880 881 // This gives us only the "orientation" component of the transform 882 const State& s(getCurrentState()); 883 884 // Apply the layer's transform, followed by the display's global transform 885 // Here we're guaranteed that the layer's transform preserves rects 886 Rect win(s.active.w, s.active.h); 887 if (!s.crop.isEmpty()) { 888 win.intersect(s.crop, &win); 889 } 890 // Subtract the transparent region and snap to the bounds 891 Rect bounds = reduce(win, s.activeTransparentRegion); 892 Rect frame(getTransform().transform(bounds)); 893 frame.intersect(displayDevice->getViewport(), &frame); 894 if (!s.finalCrop.isEmpty()) { 895 frame.intersect(s.finalCrop, &frame); 896 } 897 auto& displayTransform(displayDevice->getTransform()); 898 auto position = displayTransform.transform(frame); 899 900 auto error = mHwcLayers[hwcId].layer->setCursorPosition(position.left, 901 position.top); 902 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set cursor position " 903 "to (%d, %d): %s (%d)", mName.string(), position.left, 904 position.top, to_string(error).c_str(), 905 static_cast<int32_t>(error)); 906} 907#else 908void Layer::setAcquireFence(const sp<const DisplayDevice>& /* hw */, 909 HWComposer::HWCLayerInterface& layer) { 910 int fenceFd = -1; 911 912 // TODO: there is a possible optimization here: we only need to set the 913 // acquire fence the first time a new buffer is acquired on EACH display. 914 915 if (layer.getCompositionType() == HWC_OVERLAY || layer.getCompositionType() == HWC_CURSOR_OVERLAY) { 916 sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence(); 917 if (fence->isValid()) { 918 fenceFd = fence->dup(); 919 if (fenceFd == -1) { 920 ALOGW("failed to dup layer fence, skipping sync: %d", errno); 921 } 922 } 923 } 924 layer.setAcquireFenceFd(fenceFd); 925} 926 927Rect Layer::getPosition( 928 const sp<const DisplayDevice>& hw) 929{ 930 // this gives us only the "orientation" component of the transform 931 const State& s(getCurrentState()); 932 933 // apply the layer's transform, followed by the display's global transform 934 // here we're guaranteed that the layer's transform preserves rects 935 Rect win(s.active.w, s.active.h); 936 if (!s.crop.isEmpty()) { 937 win.intersect(s.crop, &win); 938 } 939 // subtract the transparent region and snap to the bounds 940 Rect bounds = reduce(win, s.activeTransparentRegion); 941 Rect frame(getTransform().transform(bounds)); 942 frame.intersect(hw->getViewport(), &frame); 943 if (!s.finalCrop.isEmpty()) { 944 frame.intersect(s.finalCrop, &frame); 945 } 946 const Transform& tr(hw->getTransform()); 947 return Rect(tr.transform(frame)); 948} 949#endif 950 951// --------------------------------------------------------------------------- 952// drawing... 953// --------------------------------------------------------------------------- 954 955void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const { 956 onDraw(hw, clip, false); 957} 958 959void Layer::draw(const sp<const DisplayDevice>& hw, 960 bool useIdentityTransform) const { 961 onDraw(hw, Region(hw->bounds()), useIdentityTransform); 962} 963 964void Layer::draw(const sp<const DisplayDevice>& hw) const { 965 onDraw(hw, Region(hw->bounds()), false); 966} 967 968void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip, 969 bool useIdentityTransform) const 970{ 971 ATRACE_CALL(); 972 973 if (CC_UNLIKELY(mActiveBuffer == 0)) { 974 // the texture has not been created yet, this Layer has 975 // in fact never been drawn into. This happens frequently with 976 // SurfaceView because the WindowManager can't know when the client 977 // has drawn the first time. 978 979 // If there is nothing under us, we paint the screen in black, otherwise 980 // we just skip this update. 981 982 // figure out if there is something below us 983 Region under; 984 bool finished = false; 985 mFlinger->mDrawingState.layersSortedByZ.traverseInZOrder([&](Layer* layer) { 986 if (finished || layer == static_cast<Layer const*>(this)) { 987 finished = true; 988 return; 989 } 990 under.orSelf( hw->getTransform().transform(layer->visibleRegion) ); 991 }); 992 // if not everything below us is covered, we plug the holes! 993 Region holes(clip.subtract(under)); 994 if (!holes.isEmpty()) { 995 clearWithOpenGL(hw, 0, 0, 0, 1); 996 } 997 return; 998 } 999 1000 // Bind the current buffer to the GL texture, and wait for it to be 1001 // ready for us to draw into. 1002 status_t err = mSurfaceFlingerConsumer->bindTextureImage(); 1003 if (err != NO_ERROR) { 1004 ALOGW("onDraw: bindTextureImage failed (err=%d)", err); 1005 // Go ahead and draw the buffer anyway; no matter what we do the screen 1006 // is probably going to have something visibly wrong. 1007 } 1008 1009 bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure()); 1010 1011 RenderEngine& engine(mFlinger->getRenderEngine()); 1012 1013 if (!blackOutLayer) { 1014 // TODO: we could be more subtle with isFixedSize() 1015 const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize(); 1016 1017 // Query the texture matrix given our current filtering mode. 1018 float textureMatrix[16]; 1019 mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering); 1020 mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix); 1021 1022 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) { 1023 1024 /* 1025 * the code below applies the primary display's inverse transform to 1026 * the texture transform 1027 */ 1028 1029 // create a 4x4 transform matrix from the display transform flags 1030 const mat4 flipH(-1,0,0,0, 0,1,0,0, 0,0,1,0, 1,0,0,1); 1031 const mat4 flipV( 1,0,0,0, 0,-1,0,0, 0,0,1,0, 0,1,0,1); 1032 const mat4 rot90( 0,1,0,0, -1,0,0,0, 0,0,1,0, 1,0,0,1); 1033 1034 mat4 tr; 1035 uint32_t transform = 1036 DisplayDevice::getPrimaryDisplayOrientationTransform(); 1037 if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90) 1038 tr = tr * rot90; 1039 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H) 1040 tr = tr * flipH; 1041 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V) 1042 tr = tr * flipV; 1043 1044 // calculate the inverse 1045 tr = inverse(tr); 1046 1047 // and finally apply it to the original texture matrix 1048 const mat4 texTransform(mat4(static_cast<const float*>(textureMatrix)) * tr); 1049 memcpy(textureMatrix, texTransform.asArray(), sizeof(textureMatrix)); 1050 } 1051 1052 // Set things up for texturing. 1053 mTexture.setDimensions(mActiveBuffer->getWidth(), mActiveBuffer->getHeight()); 1054 mTexture.setFiltering(useFiltering); 1055 mTexture.setMatrix(textureMatrix); 1056 1057 engine.setupLayerTexturing(mTexture); 1058 } else { 1059 engine.setupLayerBlackedOut(); 1060 } 1061 drawWithOpenGL(hw, useIdentityTransform); 1062 engine.disableTexturing(); 1063} 1064 1065 1066void Layer::clearWithOpenGL(const sp<const DisplayDevice>& hw, 1067 float red, float green, float blue, 1068 float alpha) const 1069{ 1070 RenderEngine& engine(mFlinger->getRenderEngine()); 1071 computeGeometry(hw, mMesh, false); 1072 engine.setupFillWithColor(red, green, blue, alpha); 1073 engine.drawMesh(mMesh); 1074} 1075 1076void Layer::clearWithOpenGL( 1077 const sp<const DisplayDevice>& hw) const { 1078 clearWithOpenGL(hw, 0,0,0,0); 1079} 1080 1081void Layer::drawWithOpenGL(const sp<const DisplayDevice>& hw, 1082 bool useIdentityTransform) const { 1083 const State& s(getDrawingState()); 1084 1085 computeGeometry(hw, mMesh, useIdentityTransform); 1086 1087 /* 1088 * NOTE: the way we compute the texture coordinates here produces 1089 * different results than when we take the HWC path -- in the later case 1090 * the "source crop" is rounded to texel boundaries. 1091 * This can produce significantly different results when the texture 1092 * is scaled by a large amount. 1093 * 1094 * The GL code below is more logical (imho), and the difference with 1095 * HWC is due to a limitation of the HWC API to integers -- a question 1096 * is suspend is whether we should ignore this problem or revert to 1097 * GL composition when a buffer scaling is applied (maybe with some 1098 * minimal value)? Or, we could make GL behave like HWC -- but this feel 1099 * like more of a hack. 1100 */ 1101 Rect win(computeBounds()); 1102 1103 Transform t = getTransform(); 1104 if (!s.finalCrop.isEmpty()) { 1105 win = t.transform(win); 1106 if (!win.intersect(s.finalCrop, &win)) { 1107 win.clear(); 1108 } 1109 win = t.inverse().transform(win); 1110 if (!win.intersect(computeBounds(), &win)) { 1111 win.clear(); 1112 } 1113 } 1114 1115 float left = float(win.left) / float(s.active.w); 1116 float top = float(win.top) / float(s.active.h); 1117 float right = float(win.right) / float(s.active.w); 1118 float bottom = float(win.bottom) / float(s.active.h); 1119 1120 // TODO: we probably want to generate the texture coords with the mesh 1121 // here we assume that we only have 4 vertices 1122 Mesh::VertexArray<vec2> texCoords(mMesh.getTexCoordArray<vec2>()); 1123 texCoords[0] = vec2(left, 1.0f - top); 1124 texCoords[1] = vec2(left, 1.0f - bottom); 1125 texCoords[2] = vec2(right, 1.0f - bottom); 1126 texCoords[3] = vec2(right, 1.0f - top); 1127 1128 RenderEngine& engine(mFlinger->getRenderEngine()); 1129 engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), s.alpha); 1130 engine.drawMesh(mMesh); 1131 engine.disableBlending(); 1132} 1133 1134#ifdef USE_HWC2 1135void Layer::setCompositionType(int32_t hwcId, HWC2::Composition type, 1136 bool callIntoHwc) { 1137 if (mHwcLayers.count(hwcId) == 0) { 1138 ALOGE("setCompositionType called without a valid HWC layer"); 1139 return; 1140 } 1141 auto& hwcInfo = mHwcLayers[hwcId]; 1142 auto& hwcLayer = hwcInfo.layer; 1143 ALOGV("setCompositionType(%" PRIx64 ", %s, %d)", hwcLayer->getId(), 1144 to_string(type).c_str(), static_cast<int>(callIntoHwc)); 1145 if (hwcInfo.compositionType != type) { 1146 ALOGV(" actually setting"); 1147 hwcInfo.compositionType = type; 1148 if (callIntoHwc) { 1149 auto error = hwcLayer->setCompositionType(type); 1150 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set " 1151 "composition type %s: %s (%d)", mName.string(), 1152 to_string(type).c_str(), to_string(error).c_str(), 1153 static_cast<int32_t>(error)); 1154 } 1155 } 1156} 1157 1158HWC2::Composition Layer::getCompositionType(int32_t hwcId) const { 1159 if (hwcId == DisplayDevice::DISPLAY_ID_INVALID) { 1160 // If we're querying the composition type for a display that does not 1161 // have a HWC counterpart, then it will always be Client 1162 return HWC2::Composition::Client; 1163 } 1164 if (mHwcLayers.count(hwcId) == 0) { 1165 ALOGE("getCompositionType called with an invalid HWC layer"); 1166 return HWC2::Composition::Invalid; 1167 } 1168 return mHwcLayers.at(hwcId).compositionType; 1169} 1170 1171void Layer::setClearClientTarget(int32_t hwcId, bool clear) { 1172 if (mHwcLayers.count(hwcId) == 0) { 1173 ALOGE("setClearClientTarget called without a valid HWC layer"); 1174 return; 1175 } 1176 mHwcLayers[hwcId].clearClientTarget = clear; 1177} 1178 1179bool Layer::getClearClientTarget(int32_t hwcId) const { 1180 if (mHwcLayers.count(hwcId) == 0) { 1181 ALOGE("getClearClientTarget called without a valid HWC layer"); 1182 return false; 1183 } 1184 return mHwcLayers.at(hwcId).clearClientTarget; 1185} 1186#endif 1187 1188uint32_t Layer::getProducerStickyTransform() const { 1189 int producerStickyTransform = 0; 1190 int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform); 1191 if (ret != OK) { 1192 ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__, 1193 strerror(-ret), ret); 1194 return 0; 1195 } 1196 return static_cast<uint32_t>(producerStickyTransform); 1197} 1198 1199bool Layer::latchUnsignaledBuffers() { 1200 static bool propertyLoaded = false; 1201 static bool latch = false; 1202 static std::mutex mutex; 1203 std::lock_guard<std::mutex> lock(mutex); 1204 if (!propertyLoaded) { 1205 char value[PROPERTY_VALUE_MAX] = {}; 1206 property_get("debug.sf.latch_unsignaled", value, "0"); 1207 latch = atoi(value); 1208 propertyLoaded = true; 1209 } 1210 return latch; 1211} 1212 1213uint64_t Layer::getHeadFrameNumber() const { 1214 Mutex::Autolock lock(mQueueItemLock); 1215 if (!mQueueItems.empty()) { 1216 return mQueueItems[0].mFrameNumber; 1217 } else { 1218 return mCurrentFrameNumber; 1219 } 1220} 1221 1222bool Layer::headFenceHasSignaled() const { 1223#ifdef USE_HWC2 1224 if (latchUnsignaledBuffers()) { 1225 return true; 1226 } 1227 1228 Mutex::Autolock lock(mQueueItemLock); 1229 if (mQueueItems.empty()) { 1230 return true; 1231 } 1232 if (mQueueItems[0].mIsDroppable) { 1233 // Even though this buffer's fence may not have signaled yet, it could 1234 // be replaced by another buffer before it has a chance to, which means 1235 // that it's possible to get into a situation where a buffer is never 1236 // able to be latched. To avoid this, grab this buffer anyway. 1237 return true; 1238 } 1239 return mQueueItems[0].mFence->getSignalTime() != INT64_MAX; 1240#else 1241 return true; 1242#endif 1243} 1244 1245bool Layer::addSyncPoint(const std::shared_ptr<SyncPoint>& point) { 1246 if (point->getFrameNumber() <= mCurrentFrameNumber) { 1247 // Don't bother with a SyncPoint, since we've already latched the 1248 // relevant frame 1249 return false; 1250 } 1251 1252 Mutex::Autolock lock(mLocalSyncPointMutex); 1253 mLocalSyncPoints.push_back(point); 1254 return true; 1255} 1256 1257void Layer::setFiltering(bool filtering) { 1258 mFiltering = filtering; 1259} 1260 1261bool Layer::getFiltering() const { 1262 return mFiltering; 1263} 1264 1265// As documented in libhardware header, formats in the range 1266// 0x100 - 0x1FF are specific to the HAL implementation, and 1267// are known to have no alpha channel 1268// TODO: move definition for device-specific range into 1269// hardware.h, instead of using hard-coded values here. 1270#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF) 1271 1272bool Layer::getOpacityForFormat(uint32_t format) { 1273 if (HARDWARE_IS_DEVICE_FORMAT(format)) { 1274 return true; 1275 } 1276 switch (format) { 1277 case HAL_PIXEL_FORMAT_RGBA_8888: 1278 case HAL_PIXEL_FORMAT_BGRA_8888: 1279 case HAL_PIXEL_FORMAT_RGBA_FP16: 1280 return false; 1281 } 1282 // in all other case, we have no blending (also for unknown formats) 1283 return true; 1284} 1285 1286// ---------------------------------------------------------------------------- 1287// local state 1288// ---------------------------------------------------------------------------- 1289 1290static void boundPoint(vec2* point, const Rect& crop) { 1291 if (point->x < crop.left) { 1292 point->x = crop.left; 1293 } 1294 if (point->x > crop.right) { 1295 point->x = crop.right; 1296 } 1297 if (point->y < crop.top) { 1298 point->y = crop.top; 1299 } 1300 if (point->y > crop.bottom) { 1301 point->y = crop.bottom; 1302 } 1303} 1304 1305void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh, 1306 bool useIdentityTransform) const 1307{ 1308 const Layer::State& s(getDrawingState()); 1309 const Transform hwTransform(hw->getTransform()); 1310 const uint32_t hw_h = hw->getHeight(); 1311 Rect win = computeBounds(); 1312 1313 vec2 lt = vec2(win.left, win.top); 1314 vec2 lb = vec2(win.left, win.bottom); 1315 vec2 rb = vec2(win.right, win.bottom); 1316 vec2 rt = vec2(win.right, win.top); 1317 1318 Transform layerTransform = getTransform(); 1319 if (!useIdentityTransform) { 1320 lt = layerTransform.transform(lt); 1321 lb = layerTransform.transform(lb); 1322 rb = layerTransform.transform(rb); 1323 rt = layerTransform.transform(rt); 1324 } 1325 1326 if (!s.finalCrop.isEmpty()) { 1327 boundPoint(<, s.finalCrop); 1328 boundPoint(&lb, s.finalCrop); 1329 boundPoint(&rb, s.finalCrop); 1330 boundPoint(&rt, s.finalCrop); 1331 } 1332 1333 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>()); 1334 position[0] = hwTransform.transform(lt); 1335 position[1] = hwTransform.transform(lb); 1336 position[2] = hwTransform.transform(rb); 1337 position[3] = hwTransform.transform(rt); 1338 for (size_t i=0 ; i<4 ; i++) { 1339 position[i].y = hw_h - position[i].y; 1340 } 1341} 1342 1343bool Layer::isOpaque(const Layer::State& s) const 1344{ 1345 // if we don't have a buffer yet, we're translucent regardless of the 1346 // layer's opaque flag. 1347 if (mActiveBuffer == 0) { 1348 return false; 1349 } 1350 1351 // if the layer has the opaque flag, then we're always opaque, 1352 // otherwise we use the current buffer's format. 1353 return ((s.flags & layer_state_t::eLayerOpaque) != 0) || mCurrentOpacity; 1354} 1355 1356bool Layer::isSecure() const 1357{ 1358 const Layer::State& s(mDrawingState); 1359 return (s.flags & layer_state_t::eLayerSecure); 1360} 1361 1362bool Layer::isProtected() const 1363{ 1364 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer); 1365 return (activeBuffer != 0) && 1366 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED); 1367} 1368 1369bool Layer::isFixedSize() const { 1370 return getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE; 1371} 1372 1373bool Layer::isCropped() const { 1374 return !mCurrentCrop.isEmpty(); 1375} 1376 1377bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const { 1378 return mNeedsFiltering || hw->needsFiltering(); 1379} 1380 1381void Layer::setVisibleRegion(const Region& visibleRegion) { 1382 // always called from main thread 1383 this->visibleRegion = visibleRegion; 1384} 1385 1386void Layer::setCoveredRegion(const Region& coveredRegion) { 1387 // always called from main thread 1388 this->coveredRegion = coveredRegion; 1389} 1390 1391void Layer::setVisibleNonTransparentRegion(const Region& 1392 setVisibleNonTransparentRegion) { 1393 // always called from main thread 1394 this->visibleNonTransparentRegion = setVisibleNonTransparentRegion; 1395} 1396 1397// ---------------------------------------------------------------------------- 1398// transaction 1399// ---------------------------------------------------------------------------- 1400 1401void Layer::pushPendingState() { 1402 if (!mCurrentState.modified) { 1403 return; 1404 } 1405 1406 // If this transaction is waiting on the receipt of a frame, generate a sync 1407 // point and send it to the remote layer. 1408 if (mCurrentState.handle != nullptr) { 1409 sp<IBinder> strongBinder = mCurrentState.handle.promote(); 1410 sp<Handle> handle = nullptr; 1411 sp<Layer> handleLayer = nullptr; 1412 if (strongBinder != nullptr) { 1413 handle = static_cast<Handle*>(strongBinder.get()); 1414 handleLayer = handle->owner.promote(); 1415 } 1416 if (strongBinder == nullptr || handleLayer == nullptr) { 1417 ALOGE("[%s] Unable to promote Layer handle", mName.string()); 1418 // If we can't promote the layer we are intended to wait on, 1419 // then it is expired or otherwise invalid. Allow this transaction 1420 // to be applied as per normal (no synchronization). 1421 mCurrentState.handle = nullptr; 1422 } else { 1423 auto syncPoint = std::make_shared<SyncPoint>( 1424 mCurrentState.frameNumber); 1425 if (handleLayer->addSyncPoint(syncPoint)) { 1426 mRemoteSyncPoints.push_back(std::move(syncPoint)); 1427 } else { 1428 // We already missed the frame we're supposed to synchronize 1429 // on, so go ahead and apply the state update 1430 mCurrentState.handle = nullptr; 1431 } 1432 } 1433 1434 // Wake us up to check if the frame has been received 1435 setTransactionFlags(eTransactionNeeded); 1436 mFlinger->setTransactionFlags(eTraversalNeeded); 1437 } 1438 mPendingStates.push_back(mCurrentState); 1439} 1440 1441void Layer::popPendingState(State* stateToCommit) { 1442 auto oldFlags = stateToCommit->flags; 1443 *stateToCommit = mPendingStates[0]; 1444 stateToCommit->flags = (oldFlags & ~stateToCommit->mask) | 1445 (stateToCommit->flags & stateToCommit->mask); 1446 1447 mPendingStates.removeAt(0); 1448} 1449 1450bool Layer::applyPendingStates(State* stateToCommit) { 1451 bool stateUpdateAvailable = false; 1452 while (!mPendingStates.empty()) { 1453 if (mPendingStates[0].handle != nullptr) { 1454 if (mRemoteSyncPoints.empty()) { 1455 // If we don't have a sync point for this, apply it anyway. It 1456 // will be visually wrong, but it should keep us from getting 1457 // into too much trouble. 1458 ALOGE("[%s] No local sync point found", mName.string()); 1459 popPendingState(stateToCommit); 1460 stateUpdateAvailable = true; 1461 continue; 1462 } 1463 1464 if (mRemoteSyncPoints.front()->getFrameNumber() != 1465 mPendingStates[0].frameNumber) { 1466 ALOGE("[%s] Unexpected sync point frame number found", 1467 mName.string()); 1468 1469 // Signal our end of the sync point and then dispose of it 1470 mRemoteSyncPoints.front()->setTransactionApplied(); 1471 mRemoteSyncPoints.pop_front(); 1472 continue; 1473 } 1474 1475 if (mRemoteSyncPoints.front()->frameIsAvailable()) { 1476 // Apply the state update 1477 popPendingState(stateToCommit); 1478 stateUpdateAvailable = true; 1479 1480 // Signal our end of the sync point and then dispose of it 1481 mRemoteSyncPoints.front()->setTransactionApplied(); 1482 mRemoteSyncPoints.pop_front(); 1483 } else { 1484 break; 1485 } 1486 } else { 1487 popPendingState(stateToCommit); 1488 stateUpdateAvailable = true; 1489 } 1490 } 1491 1492 // If we still have pending updates, wake SurfaceFlinger back up and point 1493 // it at this layer so we can process them 1494 if (!mPendingStates.empty()) { 1495 setTransactionFlags(eTransactionNeeded); 1496 mFlinger->setTransactionFlags(eTraversalNeeded); 1497 } 1498 1499 mCurrentState.modified = false; 1500 return stateUpdateAvailable; 1501} 1502 1503void Layer::notifyAvailableFrames() { 1504 auto headFrameNumber = getHeadFrameNumber(); 1505 bool headFenceSignaled = headFenceHasSignaled(); 1506 Mutex::Autolock lock(mLocalSyncPointMutex); 1507 for (auto& point : mLocalSyncPoints) { 1508 if (headFrameNumber >= point->getFrameNumber() && headFenceSignaled) { 1509 point->setFrameAvailable(); 1510 } 1511 } 1512} 1513 1514uint32_t Layer::doTransaction(uint32_t flags) { 1515 ATRACE_CALL(); 1516 1517 pushPendingState(); 1518 Layer::State c = getCurrentState(); 1519 if (!applyPendingStates(&c)) { 1520 return 0; 1521 } 1522 1523 const Layer::State& s(getDrawingState()); 1524 1525 const bool sizeChanged = (c.requested.w != s.requested.w) || 1526 (c.requested.h != s.requested.h); 1527 1528 if (sizeChanged) { 1529 // the size changed, we need to ask our client to request a new buffer 1530 ALOGD_IF(DEBUG_RESIZE, 1531 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n" 1532 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1533 " requested={ wh={%4u,%4u} }}\n" 1534 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n" 1535 " requested={ wh={%4u,%4u} }}\n", 1536 this, getName().string(), mCurrentTransform, 1537 getEffectiveScalingMode(), 1538 c.active.w, c.active.h, 1539 c.crop.left, 1540 c.crop.top, 1541 c.crop.right, 1542 c.crop.bottom, 1543 c.crop.getWidth(), 1544 c.crop.getHeight(), 1545 c.requested.w, c.requested.h, 1546 s.active.w, s.active.h, 1547 s.crop.left, 1548 s.crop.top, 1549 s.crop.right, 1550 s.crop.bottom, 1551 s.crop.getWidth(), 1552 s.crop.getHeight(), 1553 s.requested.w, s.requested.h); 1554 1555 // record the new size, form this point on, when the client request 1556 // a buffer, it'll get the new size. 1557 mSurfaceFlingerConsumer->setDefaultBufferSize( 1558 c.requested.w, c.requested.h); 1559 } 1560 1561 const bool resizePending = (c.requested.w != c.active.w) || 1562 (c.requested.h != c.active.h); 1563 if (!isFixedSize()) { 1564 if (resizePending && mSidebandStream == NULL) { 1565 // don't let Layer::doTransaction update the drawing state 1566 // if we have a pending resize, unless we are in fixed-size mode. 1567 // the drawing state will be updated only once we receive a buffer 1568 // with the correct size. 1569 // 1570 // in particular, we want to make sure the clip (which is part 1571 // of the geometry state) is latched together with the size but is 1572 // latched immediately when no resizing is involved. 1573 // 1574 // If a sideband stream is attached, however, we want to skip this 1575 // optimization so that transactions aren't missed when a buffer 1576 // never arrives 1577 1578 flags |= eDontUpdateGeometryState; 1579 } 1580 } 1581 1582 // always set active to requested, unless we're asked not to 1583 // this is used by Layer, which special cases resizes. 1584 if (flags & eDontUpdateGeometryState) { 1585 } else { 1586 Layer::State& editCurrentState(getCurrentState()); 1587 if (mFreezePositionUpdates) { 1588 float tx = c.active.transform.tx(); 1589 float ty = c.active.transform.ty(); 1590 c.active = c.requested; 1591 c.active.transform.set(tx, ty); 1592 editCurrentState.active = c.active; 1593 } else { 1594 editCurrentState.active = editCurrentState.requested; 1595 c.active = c.requested; 1596 } 1597 } 1598 1599 if (s.active != c.active) { 1600 // invalidate and recompute the visible regions if needed 1601 flags |= Layer::eVisibleRegion; 1602 } 1603 1604 if (c.sequence != s.sequence) { 1605 // invalidate and recompute the visible regions if needed 1606 flags |= eVisibleRegion; 1607 this->contentDirty = true; 1608 1609 // we may use linear filtering, if the matrix scales us 1610 const uint8_t type = c.active.transform.getType(); 1611 mNeedsFiltering = (!c.active.transform.preserveRects() || 1612 (type >= Transform::SCALE)); 1613 } 1614 1615 // If the layer is hidden, signal and clear out all local sync points so 1616 // that transactions for layers depending on this layer's frames becoming 1617 // visible are not blocked 1618 if (c.flags & layer_state_t::eLayerHidden) { 1619 clearSyncPoints(); 1620 } 1621 1622 // Commit the transaction 1623 commitTransaction(c); 1624 return flags; 1625} 1626 1627void Layer::commitTransaction(const State& stateToCommit) { 1628 mDrawingState = stateToCommit; 1629} 1630 1631uint32_t Layer::getTransactionFlags(uint32_t flags) { 1632 return android_atomic_and(~flags, &mTransactionFlags) & flags; 1633} 1634 1635uint32_t Layer::setTransactionFlags(uint32_t flags) { 1636 return android_atomic_or(flags, &mTransactionFlags); 1637} 1638 1639bool Layer::setPosition(float x, float y, bool immediate) { 1640 if (mCurrentState.requested.transform.tx() == x && mCurrentState.requested.transform.ty() == y) 1641 return false; 1642 mCurrentState.sequence++; 1643 1644 // We update the requested and active position simultaneously because 1645 // we want to apply the position portion of the transform matrix immediately, 1646 // but still delay scaling when resizing a SCALING_MODE_FREEZE layer. 1647 mCurrentState.requested.transform.set(x, y); 1648 if (immediate && !mFreezePositionUpdates) { 1649 mCurrentState.active.transform.set(x, y); 1650 } 1651 mFreezePositionUpdates = mFreezePositionUpdates || !immediate; 1652 1653 mCurrentState.modified = true; 1654 setTransactionFlags(eTransactionNeeded); 1655 return true; 1656} 1657 1658bool Layer::setChildLayer(const sp<Layer>& childLayer, int32_t z) { 1659 ssize_t idx = mCurrentChildren.indexOf(childLayer); 1660 if (idx < 0) { 1661 return false; 1662 } 1663 if (childLayer->setLayer(z)) { 1664 mCurrentChildren.removeAt(idx); 1665 mCurrentChildren.add(childLayer); 1666 } 1667 return true; 1668} 1669 1670bool Layer::setLayer(int32_t z) { 1671 if (mCurrentState.z == z) 1672 return false; 1673 mCurrentState.sequence++; 1674 mCurrentState.z = z; 1675 mCurrentState.modified = true; 1676 setTransactionFlags(eTransactionNeeded); 1677 return true; 1678} 1679 1680bool Layer::setSize(uint32_t w, uint32_t h) { 1681 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) 1682 return false; 1683 mCurrentState.requested.w = w; 1684 mCurrentState.requested.h = h; 1685 mCurrentState.modified = true; 1686 setTransactionFlags(eTransactionNeeded); 1687 return true; 1688} 1689#ifdef USE_HWC2 1690bool Layer::setAlpha(float alpha) { 1691#else 1692bool Layer::setAlpha(uint8_t alpha) { 1693#endif 1694 if (mCurrentState.alpha == alpha) 1695 return false; 1696 mCurrentState.sequence++; 1697 mCurrentState.alpha = alpha; 1698 mCurrentState.modified = true; 1699 setTransactionFlags(eTransactionNeeded); 1700 return true; 1701} 1702bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { 1703 mCurrentState.sequence++; 1704 mCurrentState.requested.transform.set( 1705 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); 1706 mCurrentState.modified = true; 1707 setTransactionFlags(eTransactionNeeded); 1708 return true; 1709} 1710bool Layer::setTransparentRegionHint(const Region& transparent) { 1711 mCurrentState.requestedTransparentRegion = transparent; 1712 mCurrentState.modified = true; 1713 setTransactionFlags(eTransactionNeeded); 1714 return true; 1715} 1716bool Layer::setFlags(uint8_t flags, uint8_t mask) { 1717 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask); 1718 if (mCurrentState.flags == newFlags) 1719 return false; 1720 mCurrentState.sequence++; 1721 mCurrentState.flags = newFlags; 1722 mCurrentState.mask = mask; 1723 mCurrentState.modified = true; 1724 setTransactionFlags(eTransactionNeeded); 1725 return true; 1726} 1727 1728bool Layer::setCrop(const Rect& crop, bool immediate) { 1729 if (mCurrentState.crop == crop) 1730 return false; 1731 mCurrentState.sequence++; 1732 mCurrentState.requestedCrop = crop; 1733 if (immediate) { 1734 mCurrentState.crop = crop; 1735 } 1736 mCurrentState.modified = true; 1737 setTransactionFlags(eTransactionNeeded); 1738 return true; 1739} 1740bool Layer::setFinalCrop(const Rect& crop) { 1741 if (mCurrentState.finalCrop == crop) 1742 return false; 1743 mCurrentState.sequence++; 1744 mCurrentState.finalCrop = crop; 1745 mCurrentState.modified = true; 1746 setTransactionFlags(eTransactionNeeded); 1747 return true; 1748} 1749 1750bool Layer::setOverrideScalingMode(int32_t scalingMode) { 1751 if (scalingMode == mOverrideScalingMode) 1752 return false; 1753 mOverrideScalingMode = scalingMode; 1754 setTransactionFlags(eTransactionNeeded); 1755 return true; 1756} 1757 1758void Layer::setInfo(uint32_t type, uint32_t appId) { 1759 mCurrentState.appId = appId; 1760 mCurrentState.type = type; 1761 mCurrentState.modified = true; 1762 setTransactionFlags(eTransactionNeeded); 1763} 1764 1765uint32_t Layer::getEffectiveScalingMode() const { 1766 if (mOverrideScalingMode >= 0) { 1767 return mOverrideScalingMode; 1768 } 1769 return mCurrentScalingMode; 1770} 1771 1772bool Layer::setLayerStack(uint32_t layerStack) { 1773 if (mCurrentState.layerStack == layerStack) 1774 return false; 1775 mCurrentState.sequence++; 1776 mCurrentState.layerStack = layerStack; 1777 mCurrentState.modified = true; 1778 setTransactionFlags(eTransactionNeeded); 1779 return true; 1780} 1781 1782bool Layer::setDataSpace(android_dataspace dataSpace) { 1783 if (mCurrentState.dataSpace == dataSpace) 1784 return false; 1785 mCurrentState.sequence++; 1786 mCurrentState.dataSpace = dataSpace; 1787 mCurrentState.modified = true; 1788 setTransactionFlags(eTransactionNeeded); 1789 return true; 1790} 1791 1792uint32_t Layer::getLayerStack() const { 1793 auto p = getParent(); 1794 if (p == nullptr) { 1795 return getDrawingState().layerStack; 1796 } 1797 return p->getLayerStack(); 1798} 1799 1800void Layer::deferTransactionUntil(const sp<IBinder>& handle, 1801 uint64_t frameNumber) { 1802 mCurrentState.handle = handle; 1803 mCurrentState.frameNumber = frameNumber; 1804 // We don't set eTransactionNeeded, because just receiving a deferral 1805 // request without any other state updates shouldn't actually induce a delay 1806 mCurrentState.modified = true; 1807 pushPendingState(); 1808 mCurrentState.handle = nullptr; 1809 mCurrentState.frameNumber = 0; 1810 mCurrentState.modified = false; 1811} 1812 1813void Layer::useSurfaceDamage() { 1814 if (mFlinger->mForceFullDamage) { 1815 surfaceDamageRegion = Region::INVALID_REGION; 1816 } else { 1817 surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage(); 1818 } 1819} 1820 1821void Layer::useEmptyDamage() { 1822 surfaceDamageRegion.clear(); 1823} 1824 1825// ---------------------------------------------------------------------------- 1826// pageflip handling... 1827// ---------------------------------------------------------------------------- 1828 1829bool Layer::shouldPresentNow(const DispSync& dispSync) const { 1830 if (mSidebandStreamChanged || mAutoRefresh) { 1831 return true; 1832 } 1833 1834 Mutex::Autolock lock(mQueueItemLock); 1835 if (mQueueItems.empty()) { 1836 return false; 1837 } 1838 auto timestamp = mQueueItems[0].mTimestamp; 1839 nsecs_t expectedPresent = 1840 mSurfaceFlingerConsumer->computeExpectedPresent(dispSync); 1841 1842 // Ignore timestamps more than a second in the future 1843 bool isPlausible = timestamp < (expectedPresent + s2ns(1)); 1844 ALOGW_IF(!isPlausible, "[%s] Timestamp %" PRId64 " seems implausible " 1845 "relative to expectedPresent %" PRId64, mName.string(), timestamp, 1846 expectedPresent); 1847 1848 bool isDue = timestamp < expectedPresent; 1849 return isDue || !isPlausible; 1850} 1851 1852bool Layer::onPreComposition(nsecs_t refreshStartTime) { 1853 if (mBufferLatched) { 1854 Mutex::Autolock lock(mFrameEventHistoryMutex); 1855 mFrameEventHistory.addPreComposition(mCurrentFrameNumber, refreshStartTime); 1856 } 1857 mRefreshPending = false; 1858 return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh; 1859} 1860 1861bool Layer::onPostComposition( 1862 const std::shared_ptr<FenceTime>& glDoneFence, 1863 const std::shared_ptr<FenceTime>& presentFence, 1864 const std::shared_ptr<FenceTime>& retireFence) { 1865 mAcquireTimeline.updateSignalTimes(); 1866 mReleaseTimeline.updateSignalTimes(); 1867 1868 // mFrameLatencyNeeded is true when a new frame was latched for the 1869 // composition. 1870 if (!mFrameLatencyNeeded) 1871 return false; 1872 1873 // Update mFrameEventHistory. 1874 { 1875 Mutex::Autolock lock(mFrameEventHistoryMutex); 1876 mFrameEventHistory.addPostComposition(mCurrentFrameNumber, 1877 glDoneFence, presentFence); 1878 mFrameEventHistory.addRetire(mPreviousFrameNumber, 1879 retireFence); 1880 } 1881 1882 // Update mFrameTracker. 1883 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp(); 1884 mFrameTracker.setDesiredPresentTime(desiredPresentTime); 1885 1886 std::shared_ptr<FenceTime> frameReadyFence = 1887 mSurfaceFlingerConsumer->getCurrentFenceTime(); 1888 if (frameReadyFence->isValid()) { 1889 mFrameTracker.setFrameReadyFence(std::move(frameReadyFence)); 1890 } else { 1891 // There was no fence for this frame, so assume that it was ready 1892 // to be presented at the desired present time. 1893 mFrameTracker.setFrameReadyTime(desiredPresentTime); 1894 } 1895 1896 if (presentFence->isValid()) { 1897 mFrameTracker.setActualPresentFence( 1898 std::shared_ptr<FenceTime>(presentFence)); 1899 } else if (retireFence->isValid()) { 1900 mFrameTracker.setActualPresentFence( 1901 std::shared_ptr<FenceTime>(retireFence)); 1902 } else { 1903 // The HWC doesn't support present fences, so use the refresh 1904 // timestamp instead. 1905 mFrameTracker.setActualPresentTime( 1906 mFlinger->getHwComposer().getRefreshTimestamp( 1907 HWC_DISPLAY_PRIMARY)); 1908 } 1909 1910 mFrameTracker.advanceFrame(); 1911 mFrameLatencyNeeded = false; 1912 return true; 1913} 1914 1915#ifdef USE_HWC2 1916void Layer::releasePendingBuffer(nsecs_t dequeueReadyTime) { 1917 mSurfaceFlingerConsumer->releasePendingBuffer(); 1918 auto releaseFenceTime = std::make_shared<FenceTime>( 1919 mSurfaceFlingerConsumer->getPrevFinalReleaseFence()); 1920 mReleaseTimeline.push(releaseFenceTime); 1921 1922 Mutex::Autolock lock(mFrameEventHistoryMutex); 1923 mFrameEventHistory.addRelease( 1924 mPreviousFrameNumber, dequeueReadyTime, std::move(releaseFenceTime)); 1925} 1926#endif 1927 1928bool Layer::isHiddenByPolicy() const { 1929 const Layer::State& s(mDrawingState); 1930 const auto& parent = getParent(); 1931 if (parent != nullptr && parent->isHiddenByPolicy()) { 1932 return true; 1933 } 1934 return s.flags & layer_state_t::eLayerHidden; 1935} 1936 1937bool Layer::isVisible() const { 1938 const Layer::State& s(mDrawingState); 1939#ifdef USE_HWC2 1940 return !(isHiddenByPolicy()) && s.alpha > 0.0f 1941 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1942#else 1943 return !(isHiddenByPolicy()) && s.alpha 1944 && (mActiveBuffer != NULL || mSidebandStream != NULL); 1945#endif 1946} 1947 1948bool Layer::allTransactionsSignaled() { 1949 auto headFrameNumber = getHeadFrameNumber(); 1950 bool matchingFramesFound = false; 1951 bool allTransactionsApplied = true; 1952 Mutex::Autolock lock(mLocalSyncPointMutex); 1953 1954 for (auto& point : mLocalSyncPoints) { 1955 if (point->getFrameNumber() > headFrameNumber) { 1956 break; 1957 } 1958 matchingFramesFound = true; 1959 1960 if (!point->frameIsAvailable()) { 1961 // We haven't notified the remote layer that the frame for 1962 // this point is available yet. Notify it now, and then 1963 // abort this attempt to latch. 1964 point->setFrameAvailable(); 1965 allTransactionsApplied = false; 1966 break; 1967 } 1968 1969 allTransactionsApplied = allTransactionsApplied && point->transactionIsApplied(); 1970 } 1971 return !matchingFramesFound || allTransactionsApplied; 1972} 1973 1974Region Layer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime) 1975{ 1976 ATRACE_CALL(); 1977 1978 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { 1979 // mSidebandStreamChanged was true 1980 mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream(); 1981 if (mSidebandStream != NULL) { 1982 setTransactionFlags(eTransactionNeeded); 1983 mFlinger->setTransactionFlags(eTraversalNeeded); 1984 } 1985 recomputeVisibleRegions = true; 1986 1987 const State& s(getDrawingState()); 1988 return getTransform().transform(Region(Rect(s.active.w, s.active.h))); 1989 } 1990 1991 Region outDirtyRegion; 1992 if (mQueuedFrames <= 0 && !mAutoRefresh) { 1993 return outDirtyRegion; 1994 } 1995 1996 // if we've already called updateTexImage() without going through 1997 // a composition step, we have to skip this layer at this point 1998 // because we cannot call updateTeximage() without a corresponding 1999 // compositionComplete() call. 2000 // we'll trigger an update in onPreComposition(). 2001 if (mRefreshPending) { 2002 return outDirtyRegion; 2003 } 2004 2005 // If the head buffer's acquire fence hasn't signaled yet, return and 2006 // try again later 2007 if (!headFenceHasSignaled()) { 2008 mFlinger->signalLayerUpdate(); 2009 return outDirtyRegion; 2010 } 2011 2012 // Capture the old state of the layer for comparisons later 2013 const State& s(getDrawingState()); 2014 const bool oldOpacity = isOpaque(s); 2015 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer; 2016 2017 if (!allTransactionsSignaled()) { 2018 mFlinger->signalLayerUpdate(); 2019 return outDirtyRegion; 2020 } 2021 2022 // This boolean is used to make sure that SurfaceFlinger's shadow copy 2023 // of the buffer queue isn't modified when the buffer queue is returning 2024 // BufferItem's that weren't actually queued. This can happen in shared 2025 // buffer mode. 2026 bool queuedBuffer = false; 2027 LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions, 2028 getProducerStickyTransform() != 0, mName.string(), 2029 mOverrideScalingMode, mFreezePositionUpdates); 2030 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r, 2031 mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer, 2032 mLastFrameNumberReceived); 2033 if (updateResult == BufferQueue::PRESENT_LATER) { 2034 // Producer doesn't want buffer to be displayed yet. Signal a 2035 // layer update so we check again at the next opportunity. 2036 mFlinger->signalLayerUpdate(); 2037 return outDirtyRegion; 2038 } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) { 2039 // If the buffer has been rejected, remove it from the shadow queue 2040 // and return early 2041 if (queuedBuffer) { 2042 Mutex::Autolock lock(mQueueItemLock); 2043 mQueueItems.removeAt(0); 2044 android_atomic_dec(&mQueuedFrames); 2045 } 2046 return outDirtyRegion; 2047 } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { 2048 // This can occur if something goes wrong when trying to create the 2049 // EGLImage for this buffer. If this happens, the buffer has already 2050 // been released, so we need to clean up the queue and bug out 2051 // early. 2052 if (queuedBuffer) { 2053 Mutex::Autolock lock(mQueueItemLock); 2054 mQueueItems.clear(); 2055 android_atomic_and(0, &mQueuedFrames); 2056 } 2057 2058 // Once we have hit this state, the shadow queue may no longer 2059 // correctly reflect the incoming BufferQueue's contents, so even if 2060 // updateTexImage starts working, the only safe course of action is 2061 // to continue to ignore updates. 2062 mUpdateTexImageFailed = true; 2063 2064 return outDirtyRegion; 2065 } 2066 2067 if (queuedBuffer) { 2068 // Autolock scope 2069 auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2070 2071 Mutex::Autolock lock(mQueueItemLock); 2072 2073 // Remove any stale buffers that have been dropped during 2074 // updateTexImage 2075 while (mQueueItems[0].mFrameNumber != currentFrameNumber) { 2076 mQueueItems.removeAt(0); 2077 android_atomic_dec(&mQueuedFrames); 2078 } 2079 2080 mQueueItems.removeAt(0); 2081 } 2082 2083 2084 // Decrement the queued-frames count. Signal another event if we 2085 // have more frames pending. 2086 if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) 2087 || mAutoRefresh) { 2088 mFlinger->signalLayerUpdate(); 2089 } 2090 2091 // update the active buffer 2092 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer(); 2093 if (mActiveBuffer == NULL) { 2094 // this can only happen if the very first buffer was rejected. 2095 return outDirtyRegion; 2096 } 2097 2098 mBufferLatched = true; 2099 mPreviousFrameNumber = mCurrentFrameNumber; 2100 mCurrentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber(); 2101 2102 { 2103 Mutex::Autolock lock(mFrameEventHistoryMutex); 2104 mFrameEventHistory.addLatch(mCurrentFrameNumber, latchTime); 2105#ifndef USE_HWC2 2106 auto releaseFenceTime = std::make_shared<FenceTime>( 2107 mSurfaceFlingerConsumer->getPrevFinalReleaseFence()); 2108 mReleaseTimeline.push(releaseFenceTime); 2109 mFrameEventHistory.addRelease( 2110 mPreviousFrameNumber, latchTime, std::move(releaseFenceTime)); 2111#endif 2112 } 2113 2114 mRefreshPending = true; 2115 mFrameLatencyNeeded = true; 2116 if (oldActiveBuffer == NULL) { 2117 // the first time we receive a buffer, we need to trigger a 2118 // geometry invalidation. 2119 recomputeVisibleRegions = true; 2120 } 2121 2122 setDataSpace(mSurfaceFlingerConsumer->getCurrentDataSpace()); 2123 2124 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop()); 2125 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform()); 2126 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode()); 2127 if ((crop != mCurrentCrop) || 2128 (transform != mCurrentTransform) || 2129 (scalingMode != mCurrentScalingMode)) 2130 { 2131 mCurrentCrop = crop; 2132 mCurrentTransform = transform; 2133 mCurrentScalingMode = scalingMode; 2134 recomputeVisibleRegions = true; 2135 } 2136 2137 if (oldActiveBuffer != NULL) { 2138 uint32_t bufWidth = mActiveBuffer->getWidth(); 2139 uint32_t bufHeight = mActiveBuffer->getHeight(); 2140 if (bufWidth != uint32_t(oldActiveBuffer->width) || 2141 bufHeight != uint32_t(oldActiveBuffer->height)) { 2142 recomputeVisibleRegions = true; 2143 } 2144 } 2145 2146 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format); 2147 if (oldOpacity != isOpaque(s)) { 2148 recomputeVisibleRegions = true; 2149 } 2150 2151 // Remove any sync points corresponding to the buffer which was just 2152 // latched 2153 { 2154 Mutex::Autolock lock(mLocalSyncPointMutex); 2155 auto point = mLocalSyncPoints.begin(); 2156 while (point != mLocalSyncPoints.end()) { 2157 if (!(*point)->frameIsAvailable() || 2158 !(*point)->transactionIsApplied()) { 2159 // This sync point must have been added since we started 2160 // latching. Don't drop it yet. 2161 ++point; 2162 continue; 2163 } 2164 2165 if ((*point)->getFrameNumber() <= mCurrentFrameNumber) { 2166 point = mLocalSyncPoints.erase(point); 2167 } else { 2168 ++point; 2169 } 2170 } 2171 } 2172 2173 // FIXME: postedRegion should be dirty & bounds 2174 Region dirtyRegion(Rect(s.active.w, s.active.h)); 2175 2176 // transform the dirty region to window-manager space 2177 outDirtyRegion = (getTransform().transform(dirtyRegion)); 2178 2179 return outDirtyRegion; 2180} 2181 2182uint32_t Layer::getEffectiveUsage(uint32_t usage) const 2183{ 2184 // TODO: should we do something special if mSecure is set? 2185 if (mProtectedByApp) { 2186 // need a hardware-protected path to external video sink 2187 usage |= GraphicBuffer::USAGE_PROTECTED; 2188 } 2189 if (mPotentialCursor) { 2190 usage |= GraphicBuffer::USAGE_CURSOR; 2191 } 2192 usage |= GraphicBuffer::USAGE_HW_COMPOSER; 2193 return usage; 2194} 2195 2196void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 2197 uint32_t orientation = 0; 2198 if (!mFlinger->mDebugDisableTransformHint) { 2199 // The transform hint is used to improve performance, but we can 2200 // only have a single transform hint, it cannot 2201 // apply to all displays. 2202 const Transform& planeTransform(hw->getTransform()); 2203 orientation = planeTransform.getOrientation(); 2204 if (orientation & Transform::ROT_INVALID) { 2205 orientation = 0; 2206 } 2207 } 2208 mSurfaceFlingerConsumer->setTransformHint(orientation); 2209} 2210 2211// ---------------------------------------------------------------------------- 2212// debugging 2213// ---------------------------------------------------------------------------- 2214 2215void Layer::dump(String8& result, Colorizer& colorizer) const 2216{ 2217 const Layer::State& s(getDrawingState()); 2218 2219 colorizer.colorize(result, Colorizer::GREEN); 2220 result.appendFormat( 2221 "+ %s %p (%s)\n", 2222 getTypeId(), this, getName().string()); 2223 colorizer.reset(result); 2224 2225 s.activeTransparentRegion.dump(result, "transparentRegion"); 2226 visibleRegion.dump(result, "visibleRegion"); 2227 surfaceDamageRegion.dump(result, "surfaceDamageRegion"); 2228 sp<Client> client(mClientRef.promote()); 2229 2230 result.appendFormat( " " 2231 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), " 2232 "crop=(%4d,%4d,%4d,%4d), finalCrop=(%4d,%4d,%4d,%4d), " 2233 "isOpaque=%1d, invalidate=%1d, " 2234#ifdef USE_HWC2 2235 "alpha=%.3f, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2236#else 2237 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n" 2238#endif 2239 " client=%p\n", 2240 getLayerStack(), s.z, 2241 s.active.transform.tx(), s.active.transform.ty(), 2242 s.active.w, s.active.h, 2243 s.crop.left, s.crop.top, 2244 s.crop.right, s.crop.bottom, 2245 s.finalCrop.left, s.finalCrop.top, 2246 s.finalCrop.right, s.finalCrop.bottom, 2247 isOpaque(s), contentDirty, 2248 s.alpha, s.flags, 2249 s.active.transform[0][0], s.active.transform[0][1], 2250 s.active.transform[1][0], s.active.transform[1][1], 2251 client.get()); 2252 2253 sp<const GraphicBuffer> buf0(mActiveBuffer); 2254 uint32_t w0=0, h0=0, s0=0, f0=0; 2255 if (buf0 != 0) { 2256 w0 = buf0->getWidth(); 2257 h0 = buf0->getHeight(); 2258 s0 = buf0->getStride(); 2259 f0 = buf0->format; 2260 } 2261 result.appendFormat( 2262 " " 2263 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X]," 2264 " queued-frames=%d, mRefreshPending=%d\n", 2265 mFormat, w0, h0, s0,f0, 2266 mQueuedFrames, mRefreshPending); 2267 2268 if (mSurfaceFlingerConsumer != 0) { 2269 mSurfaceFlingerConsumer->dumpState(result, " "); 2270 } 2271} 2272 2273#ifdef USE_HWC2 2274void Layer::miniDumpHeader(String8& result) { 2275 result.append("----------------------------------------"); 2276 result.append("---------------------------------------\n"); 2277 result.append(" Layer name\n"); 2278 result.append(" Z | "); 2279 result.append(" Comp Type | "); 2280 result.append(" Disp Frame (LTRB) | "); 2281 result.append(" Source Crop (LTRB)\n"); 2282 result.append("----------------------------------------"); 2283 result.append("---------------------------------------\n"); 2284} 2285 2286void Layer::miniDump(String8& result, int32_t hwcId) const { 2287 if (mHwcLayers.count(hwcId) == 0) { 2288 return; 2289 } 2290 2291 String8 name; 2292 if (mName.length() > 77) { 2293 std::string shortened; 2294 shortened.append(mName.string(), 36); 2295 shortened.append("[...]"); 2296 shortened.append(mName.string() + (mName.length() - 36), 36); 2297 name = shortened.c_str(); 2298 } else { 2299 name = mName; 2300 } 2301 2302 result.appendFormat(" %s\n", name.string()); 2303 2304 const Layer::State& layerState(getDrawingState()); 2305 const HWCInfo& hwcInfo = mHwcLayers.at(hwcId); 2306 result.appendFormat(" %10u | ", layerState.z); 2307 result.appendFormat("%10s | ", 2308 to_string(getCompositionType(hwcId)).c_str()); 2309 const Rect& frame = hwcInfo.displayFrame; 2310 result.appendFormat("%4d %4d %4d %4d | ", frame.left, frame.top, 2311 frame.right, frame.bottom); 2312 const gfx::FloatRect& crop = hwcInfo.sourceCrop; 2313 result.appendFormat("%6.1f %6.1f %6.1f %6.1f\n", crop.left, crop.top, 2314 crop.right, crop.bottom); 2315 2316 result.append("- - - - - - - - - - - - - - - - - - - - "); 2317 result.append("- - - - - - - - - - - - - - - - - - - -\n"); 2318} 2319#endif 2320 2321void Layer::dumpFrameStats(String8& result) const { 2322 mFrameTracker.dumpStats(result); 2323} 2324 2325void Layer::clearFrameStats() { 2326 mFrameTracker.clearStats(); 2327} 2328 2329void Layer::logFrameStats() { 2330 mFrameTracker.logAndResetStats(mName); 2331} 2332 2333void Layer::getFrameStats(FrameStats* outStats) const { 2334 mFrameTracker.getStats(outStats); 2335} 2336 2337void Layer::dumpFrameEvents(String8& result) { 2338 result.appendFormat("- Layer %s (%s, %p)\n", 2339 getName().string(), getTypeId(), this); 2340 Mutex::Autolock lock(mFrameEventHistoryMutex); 2341 mFrameEventHistory.checkFencesForCompletion(); 2342 mFrameEventHistory.dump(result); 2343} 2344 2345void Layer::addAndGetFrameTimestamps(const NewFrameEventsEntry* newTimestamps, 2346 FrameEventHistoryDelta *outDelta) { 2347 Mutex::Autolock lock(mFrameEventHistoryMutex); 2348 if (newTimestamps) { 2349 mAcquireTimeline.push(newTimestamps->acquireFence); 2350 mFrameEventHistory.addQueue(*newTimestamps); 2351 } 2352 2353 if (outDelta) { 2354 mFrameEventHistory.getAndResetDelta(outDelta); 2355 } 2356} 2357 2358std::vector<OccupancyTracker::Segment> Layer::getOccupancyHistory( 2359 bool forceFlush) { 2360 std::vector<OccupancyTracker::Segment> history; 2361 status_t result = mSurfaceFlingerConsumer->getOccupancyHistory(forceFlush, 2362 &history); 2363 if (result != NO_ERROR) { 2364 ALOGW("[%s] Failed to obtain occupancy history (%d)", mName.string(), 2365 result); 2366 return {}; 2367 } 2368 return history; 2369} 2370 2371bool Layer::getTransformToDisplayInverse() const { 2372 return mSurfaceFlingerConsumer->getTransformToDisplayInverse(); 2373} 2374 2375void Layer::addChild(const sp<Layer>& layer) { 2376 mCurrentChildren.add(layer); 2377 layer->setParent(this); 2378} 2379 2380ssize_t Layer::removeChild(const sp<Layer>& layer) { 2381 layer->setParent(nullptr); 2382 return mCurrentChildren.remove(layer); 2383} 2384 2385bool Layer::reparentChildren(const sp<IBinder>& newParentHandle) { 2386 sp<Handle> handle = nullptr; 2387 sp<Layer> newParent = nullptr; 2388 if (newParentHandle == nullptr) { 2389 return false; 2390 } 2391 handle = static_cast<Handle*>(newParentHandle.get()); 2392 newParent = handle->owner.promote(); 2393 if (newParent == nullptr) { 2394 ALOGE("Unable to promote Layer handle"); 2395 return false; 2396 } 2397 2398 for (const sp<Layer>& child : mCurrentChildren) { 2399 newParent->addChild(child); 2400 2401 sp<Client> client(child->mClientRef.promote()); 2402 if (client != nullptr) { 2403 client->setParentLayer(newParent); 2404 } 2405 } 2406 mCurrentChildren.clear(); 2407 2408 return true; 2409} 2410 2411void Layer::setParent(const sp<Layer>& layer) { 2412 mParent = layer; 2413} 2414 2415void Layer::clearSyncPoints() { 2416 for (const auto& child : mCurrentChildren) { 2417 child->clearSyncPoints(); 2418 } 2419 2420 Mutex::Autolock lock(mLocalSyncPointMutex); 2421 for (auto& point : mLocalSyncPoints) { 2422 point->setFrameAvailable(); 2423 } 2424 mLocalSyncPoints.clear(); 2425} 2426 2427int32_t Layer::getZ() const { 2428 return mDrawingState.z; 2429} 2430 2431/** 2432 * Negatively signed children are before 'this' in Z-order. 2433 */ 2434void Layer::traverseInZOrder(const std::function<void(Layer*)>& exec) { 2435 size_t i = 0; 2436 for (; i < mDrawingChildren.size(); i++) { 2437 const auto& child = mDrawingChildren[i]; 2438 if (child->getZ() >= 0) 2439 break; 2440 child->traverseInZOrder(exec); 2441 } 2442 exec(this); 2443 for (; i < mDrawingChildren.size(); i++) { 2444 const auto& child = mDrawingChildren[i]; 2445 child->traverseInZOrder(exec); 2446 } 2447} 2448 2449/** 2450 * Positively signed children are before 'this' in reverse Z-order. 2451 */ 2452void Layer::traverseInReverseZOrder(const std::function<void(Layer*)>& exec) { 2453 int32_t i = 0; 2454 for (i = mDrawingChildren.size()-1; i>=0; i--) { 2455 const auto& child = mDrawingChildren[i]; 2456 if (child->getZ() < 0) { 2457 break; 2458 } 2459 child->traverseInReverseZOrder(exec); 2460 } 2461 exec(this); 2462 for (; i>=0; i--) { 2463 const auto& child = mDrawingChildren[i]; 2464 child->traverseInReverseZOrder(exec); 2465 } 2466} 2467 2468Transform Layer::getTransform() const { 2469 Transform t; 2470 const auto& p = getParent(); 2471 if (p != nullptr) { 2472 t = p->getTransform(); 2473 } 2474 return t * getDrawingState().active.transform; 2475} 2476 2477void Layer::commitChildList() { 2478 for (size_t i = 0; i < mCurrentChildren.size(); i++) { 2479 const auto& child = mCurrentChildren[i]; 2480 child->commitChildList(); 2481 } 2482 mDrawingChildren = mCurrentChildren; 2483} 2484 2485// --------------------------------------------------------------------------- 2486 2487}; // namespace android 2488 2489#if defined(__gl_h_) 2490#error "don't include gl/gl.h in this file" 2491#endif 2492 2493#if defined(__gl2_h_) 2494#error "don't include gl2/gl2.h in this file" 2495#endif 2496