services/surfaceflinger/Layer.cpp

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