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 ATRACE_TAG ATRACE_TAG_GRAPHICS
  18
  19 #include <stdlib.h>
  20 #include <stdint.h>
  21 #include <sys/types.h>
  22 #include <math.h>
  23
  24 #include <cutils/compiler.h>
  25 #include <cutils/native_handle.h>
  26 #include <cutils/properties.h>
  27
  28 #include <utils/Errors.h>
  29 #include <utils/Log.h>
  30 #include <utils/StopWatch.h>
  31 #include <utils/Trace.h>
  32
  33 #include <ui/GraphicBuffer.h>
  34 #include <ui/PixelFormat.h>
  35
  36 #include <gui/Surface.h>
  37
  38 #include "clz.h"
  39 #include "Colorizer.h"
  40 #include "DisplayDevice.h"
  41 #include "Layer.h"
  42 #include "SurfaceFlinger.h"
  43 #include "SurfaceTextureLayer.h"
  44
  45 #include "DisplayHardware/HWComposer.h"
  46
  47 #include "RenderEngine/RenderEngine.h"
  48
  49 #define DEBUG_RESIZE    0
  50
  51 namespace android {
  52
  53 // ---------------------------------------------------------------------------
  54
  55 int32_t Layer::sSequence = 1;
  56
  57 Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client,
  58         const String8& name, uint32_t w, uint32_t h, uint32_t flags)
  59     :   contentDirty(false),
  60         sequence(uint32_t(android_atomic_inc(&sSequence))),
  61         mFlinger(flinger),
  62         mTextureName(-1U),
  63         mPremultipliedAlpha(true),
  64         mName("unnamed"),
  65         mDebug(false),
  66         mFormat(PIXEL_FORMAT_NONE),
  67         mOpaqueLayer(true),
  68         mTransactionFlags(0),
  69         mQueuedFrames(0),
  70         mCurrentTransform(0),
  71         mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
  72         mCurrentOpacity(true),
  73         mRefreshPending(false),
  74         mFrameLatencyNeeded(false),
  75         mFiltering(false),
  76         mNeedsFiltering(false),
  77         mSecure(false),
  78         mProtectedByApp(false),
  79         mHasSurface(false),
  80         mClientRef(client)
  81 {
  82     mCurrentCrop.makeInvalid();
  83     glGenTextures(1, &mTextureName);
  84
  85     uint32_t layerFlags = 0;
  86     if (flags & ISurfaceComposerClient::eHidden)
  87         layerFlags = layer_state_t::eLayerHidden;
  88
  89     if (flags & ISurfaceComposerClient::eNonPremultiplied)
  90         mPremultipliedAlpha = false;
  91
  92     mName = name;
  93
  94     mCurrentState.active.w = w;
  95     mCurrentState.active.h = h;
  96     mCurrentState.active.crop.makeInvalid();
  97     mCurrentState.z = 0;
  98     mCurrentState.alpha = 0xFF;
  99     mCurrentState.layerStack = 0;
 100     mCurrentState.flags = layerFlags;
 101     mCurrentState.sequence = 0;
 102     mCurrentState.transform.set(0, 0);
 103     mCurrentState.requested = mCurrentState.active;
 104
 105     // drawing state & current state are identical
 106     mDrawingState = mCurrentState;
 107
 108     nsecs_t displayPeriod =
 109             flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
 110     mFrameTracker.setDisplayRefreshPeriod(displayPeriod);
 111 }
 112
 113 void Layer::onFirstRef()
 114 {
 115     // Creates a custom BufferQueue for SurfaceFlingerConsumer to use
 116     mBufferQueue = new SurfaceTextureLayer(mFlinger);
 117     mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(mBufferQueue, mTextureName,
 118             GL_TEXTURE_EXTERNAL_OES, false);
 119
 120     mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
 121     mSurfaceFlingerConsumer->setFrameAvailableListener(this);
 122     mSurfaceFlingerConsumer->setName(mName);
 123
 124 #ifdef TARGET_DISABLE_TRIPLE_BUFFERING
 125 #warning "disabling triple buffering"
 126     mSurfaceFlingerConsumer->setDefaultMaxBufferCount(2);
 127 #else
 128     mSurfaceFlingerConsumer->setDefaultMaxBufferCount(3);
 129 #endif
 130
 131     const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice());
 132     updateTransformHint(hw);
 133 }
 134
 135 Layer::~Layer() {
 136     sp<Client> c(mClientRef.promote());
 137     if (c != 0) {
 138         c->detachLayer(this);
 139     }
 140     mFlinger->deleteTextureAsync(mTextureName);
 141     mFrameTracker.logAndResetStats(mName);
 142 }
 143
 144 // ---------------------------------------------------------------------------
 145 // callbacks
 146 // ---------------------------------------------------------------------------
 147
 148 void Layer::onLayerDisplayed(const sp<const DisplayDevice>& hw,
 149         HWComposer::HWCLayerInterface* layer) {
 150     if (layer) {
 151         layer->onDisplayed();
 152         mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFence());
 153     }
 154 }
 155
 156 void Layer::onFrameAvailable() {
 157     android_atomic_inc(&mQueuedFrames);
 158     mFlinger->signalLayerUpdate();
 159 }
 160
 161 // called with SurfaceFlinger::mStateLock from the drawing thread after
 162 // the layer has been remove from the current state list (and just before
 163 // it's removed from the drawing state list)
 164 void Layer::onRemoved() {
 165     mSurfaceFlingerConsumer->abandon();
 166 }
 167
 168 // ---------------------------------------------------------------------------
 169 // set-up
 170 // ---------------------------------------------------------------------------
 171
 172 const String8& Layer::getName() const {
 173     return mName;
 174 }
 175
 176 status_t Layer::setBuffers( uint32_t w, uint32_t h,
 177                             PixelFormat format, uint32_t flags)
 178 {
 179     uint32_t const maxSurfaceDims = min(
 180             mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims());
 181
 182     // never allow a surface larger than what our underlying GL implementation
 183     // can handle.
 184     if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) {
 185         ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h));
 186         return BAD_VALUE;
 187     }
 188
 189     mFormat = format;
 190
 191     mSecure = (flags & ISurfaceComposerClient::eSecure) ? true : false;
 192     mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false;
 193     mOpaqueLayer = (flags & ISurfaceComposerClient::eOpaque);
 194     mCurrentOpacity = getOpacityForFormat(format);
 195
 196     mSurfaceFlingerConsumer->setDefaultBufferSize(w, h);
 197     mSurfaceFlingerConsumer->setDefaultBufferFormat(format);
 198     mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
 199
 200     return NO_ERROR;
 201 }
 202
 203 sp<IBinder> Layer::getHandle() {
 204     Mutex::Autolock _l(mLock);
 205
 206     LOG_ALWAYS_FATAL_IF(mHasSurface,
 207             "Layer::getHandle() has already been called");
 208
 209     mHasSurface = true;
 210
 211     /*
 212      * The layer handle is just a BBinder object passed to the client
 213      * (remote process) -- we don't keep any reference on our side such that
 214      * the dtor is called when the remote side let go of its reference.
 215      *
 216      * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for
 217      * this layer when the handle is destroyed.
 218      */
 219
 220     class Handle : public BBinder, public LayerCleaner {
 221         wp<const Layer> mOwner;
 222     public:
 223         Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
 224             : LayerCleaner(flinger, layer), mOwner(layer) {
 225         }
 226     };
 227
 228     return new Handle(mFlinger, this);
 229 }
 230
 231 sp<IGraphicBufferProducer> Layer::getBufferQueue() const {
 232     return mBufferQueue;
 233 }
 234
 235 // ---------------------------------------------------------------------------
 236 // h/w composer set-up
 237 // ---------------------------------------------------------------------------
 238
 239 Rect Layer::getContentCrop() const {
 240     // this is the crop rectangle that applies to the buffer
 241     // itself (as opposed to the window)
 242     Rect crop;
 243     if (!mCurrentCrop.isEmpty()) {
 244         // if the buffer crop is defined, we use that
 245         crop = mCurrentCrop;
 246     } else if (mActiveBuffer != NULL) {
 247         // otherwise we use the whole buffer
 248         crop = mActiveBuffer->getBounds();
 249     } else {
 250         // if we don't have a buffer yet, we use an empty/invalid crop
 251         crop.makeInvalid();
 252     }
 253     return crop;
 254 }
 255
 256 static Rect reduce(const Rect& win, const Region& exclude) {
 257     if (CC_LIKELY(exclude.isEmpty())) {
 258         return win;
 259     }
 260     if (exclude.isRect()) {
 261         return win.reduce(exclude.getBounds());
 262     }
 263     return Region(win).subtract(exclude).getBounds();
 264 }
 265
 266 Rect Layer::computeBounds() const {
 267     const Layer::State& s(getDrawingState());
 268     Rect win(s.active.w, s.active.h);
 269     if (!s.active.crop.isEmpty()) {
 270         win.intersect(s.active.crop, &win);
 271     }
 272     // subtract the transparent region and snap to the bounds
 273     return reduce(win, s.activeTransparentRegion);
 274 }
 275
 276 FloatRect Layer::computeCrop(const sp<const DisplayDevice>& hw) const {
 277     // the content crop is the area of the content that gets scaled to the
 278     // layer's size.
 279     FloatRect crop(getContentCrop());
 280
 281     // the active.crop is the area of the window that gets cropped, but not
 282     // scaled in any ways.
 283     const State& s(getDrawingState());
 284
 285     // apply the projection's clipping to the window crop in
 286     // layerstack space, and convert-back to layer space.
 287     // if there are no window scaling involved, this operation will map to full
 288     // pixels in the buffer.
 289     // FIXME: the 3 lines below can produce slightly incorrect clipping when we have
 290     // a viewport clipping and a window transform. we should use floating point to fix this.
 291     Rect activeCrop(s.transform.transform(s.active.crop));
 292     activeCrop.intersect(hw->getViewport(), &activeCrop);
 293     activeCrop = s.transform.inverse().transform(activeCrop);
 294
 295     // paranoia: make sure the window-crop is constrained in the
 296     // window's bounds
 297     activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop);
 298
 299     // subtract the transparent region and snap to the bounds
 300     activeCrop = reduce(activeCrop, s.activeTransparentRegion);
 301
 302     if (!activeCrop.isEmpty()) {
 303         // Transform the window crop to match the buffer coordinate system,
 304         // which means using the inverse of the current transform set on the
 305         // SurfaceFlingerConsumer.
 306         uint32_t invTransform = mCurrentTransform;
 307         int winWidth = s.active.w;
 308         int winHeight = s.active.h;
 309         if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
 310             invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V |
 311                     NATIVE_WINDOW_TRANSFORM_FLIP_H;
 312             winWidth = s.active.h;
 313             winHeight = s.active.w;
 314         }
 315         const Rect winCrop = activeCrop.transform(
 316                 invTransform, s.active.w, s.active.h);
 317
 318         // below, crop is intersected with winCrop expressed in crop's coordinate space
 319         float xScale = crop.getWidth()  / float(winWidth);
 320         float yScale = crop.getHeight() / float(winHeight);
 321
 322         float insetL = winCrop.left                 * xScale;
 323         float insetT = winCrop.top                  * yScale;
 324         float insetR = (winWidth  - winCrop.right ) * xScale;
 325         float insetB = (winHeight - winCrop.bottom) * yScale;
 326
 327         crop.left   += insetL;
 328         crop.top    += insetT;
 329         crop.right  -= insetR;
 330         crop.bottom -= insetB;
 331     }
 332     return crop;
 333 }
 334
 335 void Layer::setGeometry(
 336     const sp<const DisplayDevice>& hw,
 337         HWComposer::HWCLayerInterface& layer)
 338 {
 339     layer.setDefaultState();
 340
 341     // enable this layer
 342     layer.setSkip(false);
 343
 344     if (isSecure() && !hw->isSecure()) {
 345         layer.setSkip(true);
 346     }
 347
 348     // this gives us only the "orientation" component of the transform
 349     const State& s(getDrawingState());
 350     if (!isOpaque() || s.alpha != 0xFF) {
 351         layer.setBlending(mPremultipliedAlpha ?
 352                 HWC_BLENDING_PREMULT :
 353                 HWC_BLENDING_COVERAGE);
 354     }
 355
 356     // apply the layer's transform, followed by the display's global transform
 357     // here we're guaranteed that the layer's transform preserves rects
 358     Rect frame(s.transform.transform(computeBounds()));
 359     frame.intersect(hw->getViewport(), &frame);
 360     const Transform& tr(hw->getTransform());
 361     layer.setFrame(tr.transform(frame));
 362     layer.setCrop(computeCrop(hw));
 363     layer.setPlaneAlpha(s.alpha);
 364
 365     /*
 366      * Transformations are applied in this order:
 367      * 1) buffer orientation/flip/mirror
 368      * 2) state transformation (window manager)
 369      * 3) layer orientation (screen orientation)
 370      * (NOTE: the matrices are multiplied in reverse order)
 371      */
 372
 373     const Transform bufferOrientation(mCurrentTransform);
 374     const Transform transform(tr * s.transform * bufferOrientation);
 375
 376     // this gives us only the "orientation" component of the transform
 377     const uint32_t orientation = transform.getOrientation();
 378     if (orientation & Transform::ROT_INVALID) {
 379         // we can only handle simple transformation
 380         layer.setSkip(true);
 381     } else {
 382         layer.setTransform(orientation);
 383     }
 384 }
 385
 386 void Layer::setPerFrameData(const sp<const DisplayDevice>& hw,
 387         HWComposer::HWCLayerInterface& layer) {
 388     // we have to set the visible region on every frame because
 389     // we currently free it during onLayerDisplayed(), which is called
 390     // after HWComposer::commit() -- every frame.
 391     // Apply this display's projection's viewport to the visible region
 392     // before giving it to the HWC HAL.
 393     const Transform& tr = hw->getTransform();
 394     Region visible = tr.transform(visibleRegion.intersect(hw->getViewport()));
 395     layer.setVisibleRegionScreen(visible);
 396
 397     // NOTE: buffer can be NULL if the client never drew into this
 398     // layer yet, or if we ran out of memory
 399     layer.setBuffer(mActiveBuffer);
 400 }
 401
 402 void Layer::setAcquireFence(const sp<const DisplayDevice>& hw,
 403         HWComposer::HWCLayerInterface& layer) {
 404     int fenceFd = -1;
 405
 406     // TODO: there is a possible optimization here: we only need to set the
 407     // acquire fence the first time a new buffer is acquired on EACH display.
 408
 409     if (layer.getCompositionType() == HWC_OVERLAY) {
 410         sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence();
 411         if (fence->isValid()) {
 412             fenceFd = fence->dup();
 413             if (fenceFd == -1) {
 414                 ALOGW("failed to dup layer fence, skipping sync: %d", errno);
 415             }
 416         }
 417     }
 418     layer.setAcquireFenceFd(fenceFd);
 419 }
 420
 421 // ---------------------------------------------------------------------------
 422 // drawing...
 423 // ---------------------------------------------------------------------------
 424
 425 void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const {
 426     onDraw(hw, clip);
 427 }
 428
 429 void Layer::draw(const sp<const DisplayDevice>& hw) {
 430     onDraw( hw, Region(hw->bounds()) );
 431 }
 432
 433 void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip) const
 434 {
 435     ATRACE_CALL();
 436
 437     if (CC_UNLIKELY(mActiveBuffer == 0)) {
 438         // the texture has not been created yet, this Layer has
 439         // in fact never been drawn into. This happens frequently with
 440         // SurfaceView because the WindowManager can't know when the client
 441         // has drawn the first time.
 442
 443         // If there is nothing under us, we paint the screen in black, otherwise
 444         // we just skip this update.
 445
 446         // figure out if there is something below us
 447         Region under;
 448         const SurfaceFlinger::LayerVector& drawingLayers(
 449                 mFlinger->mDrawingState.layersSortedByZ);
 450         const size_t count = drawingLayers.size();
 451         for (size_t i=0 ; i<count ; ++i) {
 452             const sp<Layer>& layer(drawingLayers[i]);
 453             if (layer.get() == static_cast<Layer const*>(this))
 454                 break;
 455             under.orSelf( hw->getTransform().transform(layer->visibleRegion) );
 456         }
 457         // if not everything below us is covered, we plug the holes!
 458         Region holes(clip.subtract(under));
 459         if (!holes.isEmpty()) {
 460             clearWithOpenGL(hw, holes, 0, 0, 0, 1);
 461         }
 462         return;
 463     }
 464
 465     // Bind the current buffer to the GL texture, and wait for it to be
 466     // ready for us to draw into.
 467     status_t err = mSurfaceFlingerConsumer->bindTextureImage();
 468     if (err != NO_ERROR) {
 469         ALOGW("onDraw: bindTextureImage failed (err=%d)", err);
 470         // Go ahead and draw the buffer anyway; no matter what we do the screen
 471         // is probably going to have something visibly wrong.
 472     }
 473
 474     bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure());
 475
 476     RenderEngine& engine(mFlinger->getRenderEngine());
 477
 478     if (!blackOutLayer) {
 479         // TODO: we could be more subtle with isFixedSize()
 480         const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize();
 481
 482         // Query the texture matrix given our current filtering mode.
 483         float textureMatrix[16];
 484         mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering);
 485         mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix);
 486
 487         // Set things up for texturing.
 488         engine.setupLayerTexturing(mTextureName, useFiltering, textureMatrix);
 489     } else {
 490         engine.setupLayerBlackedOut();
 491     }
 492     drawWithOpenGL(hw, clip);
 493     engine.disableTexturing();
 494 }
 495
 496
 497 void Layer::clearWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip,
 498         GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) const
 499 {
 500     LayerMesh mesh;
 501     computeGeometry(hw, &mesh);
 502
 503     mFlinger->getRenderEngine().clearWithColor(
 504         mesh.getVertices(), mesh.getVertexCount(),
 505         red, green, blue, alpha);
 506 }
 507
 508 void Layer::clearWithOpenGL(
 509         const sp<const DisplayDevice>& hw, const Region& clip) const {
 510     clearWithOpenGL(hw, clip, 0,0,0,0);
 511 }
 512
 513 void Layer::drawWithOpenGL(
 514         const sp<const DisplayDevice>& hw, const Region& clip) const {
 515     const uint32_t fbHeight = hw->getHeight();
 516     const State& s(getDrawingState());
 517
 518     LayerMesh mesh;
 519     computeGeometry(hw, &mesh);
 520
 521     /*
 522      * NOTE: the way we compute the texture coordinates here produces
 523      * different results than when we take the HWC path -- in the later case
 524      * the "source crop" is rounded to texel boundaries.
 525      * This can produce significantly different results when the texture
 526      * is scaled by a large amount.
 527      *
 528      * The GL code below is more logical (imho), and the difference with
 529      * HWC is due to a limitation of the HWC API to integers -- a question
 530      * is suspend is wether we should ignore this problem or revert to
 531      * GL composition when a buffer scaling is applied (maybe with some
 532      * minimal value)? Or, we could make GL behave like HWC -- but this feel
 533      * like more of a hack.
 534      */
 535     const Rect win(computeBounds());
 536
 537     GLfloat left   = GLfloat(win.left)   / GLfloat(s.active.w);
 538     GLfloat top    = GLfloat(win.top)    / GLfloat(s.active.h);
 539     GLfloat right  = GLfloat(win.right)  / GLfloat(s.active.w);
 540     GLfloat bottom = GLfloat(win.bottom) / GLfloat(s.active.h);
 541
 542     // TODO: we probably want to generate the texture coords with the mesh
 543     // here we assume that we only have 4 vertices
 544     float texCoords[4][2];
 545     texCoords[0][0] = left;
 546     texCoords[0][1] = top;
 547     texCoords[1][0] = left;
 548     texCoords[1][1] = bottom;
 549     texCoords[2][0] = right;
 550     texCoords[2][1] = bottom;
 551     texCoords[3][0] = right;
 552     texCoords[3][1] = top;
 553     for (int i = 0; i < 4; i++) {
 554         texCoords[i][1] = 1.0f - texCoords[i][1];
 555     }
 556
 557     RenderEngine& engine(mFlinger->getRenderEngine());
 558     engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(), s.alpha);
 559     engine.drawMesh2D(mesh.getVertices(), texCoords, mesh.getVertexCount());
 560     engine.disableBlending();
 561 }
 562
 563 void Layer::setFiltering(bool filtering) {
 564     mFiltering = filtering;
 565 }
 566
 567 bool Layer::getFiltering() const {
 568     return mFiltering;
 569 }
 570
 571 // As documented in libhardware header, formats in the range
 572 // 0x100 - 0x1FF are specific to the HAL implementation, and
 573 // are known to have no alpha channel
 574 // TODO: move definition for device-specific range into
 575 // hardware.h, instead of using hard-coded values here.
 576 #define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF)
 577
 578 bool Layer::getOpacityForFormat(uint32_t format) {
 579     if (HARDWARE_IS_DEVICE_FORMAT(format)) {
 580         return true;
 581     }
 582     switch (format) {
 583         case HAL_PIXEL_FORMAT_RGBA_8888:
 584         case HAL_PIXEL_FORMAT_BGRA_8888:
 585             return false;
 586     }
 587     // in all other case, we have no blending (also for unknown formats)
 588     return true;
 589 }
 590
 591 // ----------------------------------------------------------------------------
 592 // local state
 593 // ----------------------------------------------------------------------------
 594
 595 void Layer::computeGeometry(const sp<const DisplayDevice>& hw, LayerMesh* mesh) const
 596 {
 597     const Layer::State& s(getDrawingState());
 598     const Transform tr(hw->getTransform() * s.transform);
 599     const uint32_t hw_h = hw->getHeight();
 600     Rect win(s.active.w, s.active.h);
 601     if (!s.active.crop.isEmpty()) {
 602         win.intersect(s.active.crop, &win);
 603     }
 604     // subtract the transparent region and snap to the bounds
 605     win = reduce(win, s.activeTransparentRegion);
 606     if (mesh) {
 607         tr.transform(mesh->mVertices[0], win.left,  win.top);
 608         tr.transform(mesh->mVertices[1], win.left,  win.bottom);
 609         tr.transform(mesh->mVertices[2], win.right, win.bottom);
 610         tr.transform(mesh->mVertices[3], win.right, win.top);
 611         for (size_t i=0 ; i<4 ; i++) {
 612             mesh->mVertices[i][1] = hw_h - mesh->mVertices[i][1];
 613         }
 614     }
 615 }
 616
 617 bool Layer::isOpaque() const
 618 {
 619     // if we don't have a buffer yet, we're translucent regardless of the
 620     // layer's opaque flag.
 621     if (mActiveBuffer == 0) {
 622         return false;
 623     }
 624
 625     // if the layer has the opaque flag, then we're always opaque,
 626     // otherwise we use the current buffer's format.
 627     return mOpaqueLayer || mCurrentOpacity;
 628 }
 629
 630 bool Layer::isProtected() const
 631 {
 632     const sp<GraphicBuffer>& activeBuffer(mActiveBuffer);
 633     return (activeBuffer != 0) &&
 634             (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED);
 635 }
 636
 637 bool Layer::isFixedSize() const {
 638     return mCurrentScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE;
 639 }
 640
 641 bool Layer::isCropped() const {
 642     return !mCurrentCrop.isEmpty();
 643 }
 644
 645 bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const {
 646     return mNeedsFiltering || hw->needsFiltering();
 647 }
 648
 649 void Layer::setVisibleRegion(const Region& visibleRegion) {
 650     // always called from main thread
 651     this->visibleRegion = visibleRegion;
 652 }
 653
 654 void Layer::setCoveredRegion(const Region& coveredRegion) {
 655     // always called from main thread
 656     this->coveredRegion = coveredRegion;
 657 }
 658
 659 void Layer::setVisibleNonTransparentRegion(const Region&
 660         setVisibleNonTransparentRegion) {
 661     // always called from main thread
 662     this->visibleNonTransparentRegion = setVisibleNonTransparentRegion;
 663 }
 664
 665 // ----------------------------------------------------------------------------
 666 // transaction
 667 // ----------------------------------------------------------------------------
 668
 669 uint32_t Layer::doTransaction(uint32_t flags) {
 670     ATRACE_CALL();
 671
 672     const Layer::State& s(getDrawingState());
 673     const Layer::State& c(getCurrentState());
 674
 675     const bool sizeChanged = (c.requested.w != s.requested.w) ||
 676                              (c.requested.h != s.requested.h);
 677
 678     if (sizeChanged) {
 679         // the size changed, we need to ask our client to request a new buffer
 680         ALOGD_IF(DEBUG_RESIZE,
 681                 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n"
 682                 "  current={ active   ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
 683                 "            requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n"
 684                 "  drawing={ active   ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
 685                 "            requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n",
 686                 this, getName().string(), mCurrentTransform, mCurrentScalingMode,
 687                 c.active.w, c.active.h,
 688                 c.active.crop.left,
 689                 c.active.crop.top,
 690                 c.active.crop.right,
 691                 c.active.crop.bottom,
 692                 c.active.crop.getWidth(),
 693                 c.active.crop.getHeight(),
 694                 c.requested.w, c.requested.h,
 695                 c.requested.crop.left,
 696                 c.requested.crop.top,
 697                 c.requested.crop.right,
 698                 c.requested.crop.bottom,
 699                 c.requested.crop.getWidth(),
 700                 c.requested.crop.getHeight(),
 701                 s.active.w, s.active.h,
 702                 s.active.crop.left,
 703                 s.active.crop.top,
 704                 s.active.crop.right,
 705                 s.active.crop.bottom,
 706                 s.active.crop.getWidth(),
 707                 s.active.crop.getHeight(),
 708                 s.requested.w, s.requested.h,
 709                 s.requested.crop.left,
 710                 s.requested.crop.top,
 711                 s.requested.crop.right,
 712                 s.requested.crop.bottom,
 713                 s.requested.crop.getWidth(),
 714                 s.requested.crop.getHeight());
 715
 716         // record the new size, form this point on, when the client request
 717         // a buffer, it'll get the new size.
 718         mSurfaceFlingerConsumer->setDefaultBufferSize(
 719                 c.requested.w, c.requested.h);
 720     }
 721
 722     if (!isFixedSize()) {
 723
 724         const bool resizePending = (c.requested.w != c.active.w) ||
 725                                    (c.requested.h != c.active.h);
 726
 727         if (resizePending) {
 728             // don't let Layer::doTransaction update the drawing state
 729             // if we have a pending resize, unless we are in fixed-size mode.
 730             // the drawing state will be updated only once we receive a buffer
 731             // with the correct size.
 732             //
 733             // in particular, we want to make sure the clip (which is part
 734             // of the geometry state) is latched together with the size but is
 735             // latched immediately when no resizing is involved.
 736
 737             flags |= eDontUpdateGeometryState;
 738         }
 739     }
 740
 741     // always set active to requested, unless we're asked not to
 742     // this is used by Layer, which special cases resizes.
 743     if (flags & eDontUpdateGeometryState)  {
 744     } else {
 745         Layer::State& editCurrentState(getCurrentState());
 746         editCurrentState.active = c.requested;
 747     }
 748
 749     if (s.active != c.active) {
 750         // invalidate and recompute the visible regions if needed
 751         flags |= Layer::eVisibleRegion;
 752     }
 753
 754     if (c.sequence != s.sequence) {
 755         // invalidate and recompute the visible regions if needed
 756         flags |= eVisibleRegion;
 757         this->contentDirty = true;
 758
 759         // we may use linear filtering, if the matrix scales us
 760         const uint8_t type = c.transform.getType();
 761         mNeedsFiltering = (!c.transform.preserveRects() ||
 762                 (type >= Transform::SCALE));
 763     }
 764
 765     // Commit the transaction
 766     commitTransaction();
 767     return flags;
 768 }
 769
 770 void Layer::commitTransaction() {
 771     mDrawingState = mCurrentState;
 772 }
 773
 774 uint32_t Layer::getTransactionFlags(uint32_t flags) {
 775     return android_atomic_and(~flags, &mTransactionFlags) & flags;
 776 }
 777
 778 uint32_t Layer::setTransactionFlags(uint32_t flags) {
 779     return android_atomic_or(flags, &mTransactionFlags);
 780 }
 781
 782 bool Layer::setPosition(float x, float y) {
 783     if (mCurrentState.transform.tx() == x && mCurrentState.transform.ty() == y)
 784         return false;
 785     mCurrentState.sequence++;
 786     mCurrentState.transform.set(x, y);
 787     setTransactionFlags(eTransactionNeeded);
 788     return true;
 789 }
 790 bool Layer::setLayer(uint32_t z) {
 791     if (mCurrentState.z == z)
 792         return false;
 793     mCurrentState.sequence++;
 794     mCurrentState.z = z;
 795     setTransactionFlags(eTransactionNeeded);
 796     return true;
 797 }
 798 bool Layer::setSize(uint32_t w, uint32_t h) {
 799     if (mCurrentState.requested.w == w && mCurrentState.requested.h == h)
 800         return false;
 801     mCurrentState.requested.w = w;
 802     mCurrentState.requested.h = h;
 803     setTransactionFlags(eTransactionNeeded);
 804     return true;
 805 }
 806 bool Layer::setAlpha(uint8_t alpha) {
 807     if (mCurrentState.alpha == alpha)
 808         return false;
 809     mCurrentState.sequence++;
 810     mCurrentState.alpha = alpha;
 811     setTransactionFlags(eTransactionNeeded);
 812     return true;
 813 }
 814 bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) {
 815     mCurrentState.sequence++;
 816     mCurrentState.transform.set(
 817             matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy);
 818     setTransactionFlags(eTransactionNeeded);
 819     return true;
 820 }
 821 bool Layer::setTransparentRegionHint(const Region& transparent) {
 822     mCurrentState.requestedTransparentRegion = transparent;
 823     setTransactionFlags(eTransactionNeeded);
 824     return true;
 825 }
 826 bool Layer::setFlags(uint8_t flags, uint8_t mask) {
 827     const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask);
 828     if (mCurrentState.flags == newFlags)
 829         return false;
 830     mCurrentState.sequence++;
 831     mCurrentState.flags = newFlags;
 832     setTransactionFlags(eTransactionNeeded);
 833     return true;
 834 }
 835 bool Layer::setCrop(const Rect& crop) {
 836     if (mCurrentState.requested.crop == crop)
 837         return false;
 838     mCurrentState.sequence++;
 839     mCurrentState.requested.crop = crop;
 840     setTransactionFlags(eTransactionNeeded);
 841     return true;
 842 }
 843
 844 bool Layer::setLayerStack(uint32_t layerStack) {
 845     if (mCurrentState.layerStack == layerStack)
 846         return false;
 847     mCurrentState.sequence++;
 848     mCurrentState.layerStack = layerStack;
 849     setTransactionFlags(eTransactionNeeded);
 850     return true;
 851 }
 852
 853 // ----------------------------------------------------------------------------
 854 // pageflip handling...
 855 // ----------------------------------------------------------------------------
 856
 857 bool Layer::onPreComposition() {
 858     mRefreshPending = false;
 859     return mQueuedFrames > 0;
 860 }
 861
 862 void Layer::onPostComposition() {
 863     if (mFrameLatencyNeeded) {
 864         nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp();
 865         mFrameTracker.setDesiredPresentTime(desiredPresentTime);
 866
 867         sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence();
 868         if (frameReadyFence->isValid()) {
 869             mFrameTracker.setFrameReadyFence(frameReadyFence);
 870         } else {
 871             // There was no fence for this frame, so assume that it was ready
 872             // to be presented at the desired present time.
 873             mFrameTracker.setFrameReadyTime(desiredPresentTime);
 874         }
 875
 876         const HWComposer& hwc = mFlinger->getHwComposer();
 877         sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY);
 878         if (presentFence->isValid()) {
 879             mFrameTracker.setActualPresentFence(presentFence);
 880         } else {
 881             // The HWC doesn't support present fences, so use the refresh
 882             // timestamp instead.
 883             nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
 884             mFrameTracker.setActualPresentTime(presentTime);
 885         }
 886
 887         mFrameTracker.advanceFrame();
 888         mFrameLatencyNeeded = false;
 889     }
 890 }
 891
 892 bool Layer::isVisible() const {
 893     const Layer::State& s(mDrawingState);
 894     return !(s.flags & layer_state_t::eLayerHidden) && s.alpha
 895             && (mActiveBuffer != NULL);
 896 }
 897
 898 Region Layer::latchBuffer(bool& recomputeVisibleRegions)
 899 {
 900     ATRACE_CALL();
 901
 902     Region outDirtyRegion;
 903     if (mQueuedFrames > 0) {
 904
 905         // if we've already called updateTexImage() without going through
 906         // a composition step, we have to skip this layer at this point
 907         // because we cannot call updateTeximage() without a corresponding
 908         // compositionComplete() call.
 909         // we'll trigger an update in onPreComposition().
 910         if (mRefreshPending) {
 911             return outDirtyRegion;
 912         }
 913
 914         // Capture the old state of the layer for comparisons later
 915         const bool oldOpacity = isOpaque();
 916         sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer;
 917
 918         struct Reject : public SurfaceFlingerConsumer::BufferRejecter {
 919             Layer::State& front;
 920             Layer::State& current;
 921             bool& recomputeVisibleRegions;
 922             Reject(Layer::State& front, Layer::State& current,
 923                     bool& recomputeVisibleRegions)
 924                 : front(front), current(current),
 925                   recomputeVisibleRegions(recomputeVisibleRegions) {
 926             }
 927
 928             virtual bool reject(const sp<GraphicBuffer>& buf,
 929                     const IGraphicBufferConsumer::BufferItem& item) {
 930                 if (buf == NULL) {
 931                     return false;
 932                 }
 933
 934                 uint32_t bufWidth  = buf->getWidth();
 935                 uint32_t bufHeight = buf->getHeight();
 936
 937                 // check that we received a buffer of the right size
 938                 // (Take the buffer's orientation into account)
 939                 if (item.mTransform & Transform::ROT_90) {
 940                     swap(bufWidth, bufHeight);
 941                 }
 942
 943                 bool isFixedSize = item.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE;
 944                 if (front.active != front.requested) {
 945
 946                     if (isFixedSize ||
 947                             (bufWidth == front.requested.w &&
 948                              bufHeight == front.requested.h))
 949                     {
 950                         // Here we pretend the transaction happened by updating the
 951                         // current and drawing states. Drawing state is only accessed
 952                         // in this thread, no need to have it locked
 953                         front.active = front.requested;
 954
 955                         // We also need to update the current state so that
 956                         // we don't end-up overwriting the drawing state with
 957                         // this stale current state during the next transaction
 958                         //
 959                         // NOTE: We don't need to hold the transaction lock here
 960                         // because State::active is only accessed from this thread.
 961                         current.active = front.active;
 962
 963                         // recompute visible region
 964                         recomputeVisibleRegions = true;
 965                     }
 966
 967                     ALOGD_IF(DEBUG_RESIZE,
 968                             "latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n"
 969                             "  drawing={ active   ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
 970                             "            requested={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }}\n",
 971                             bufWidth, bufHeight, item.mTransform, item.mScalingMode,
 972                             front.active.w, front.active.h,
 973                             front.active.crop.left,
 974                             front.active.crop.top,
 975                             front.active.crop.right,
 976                             front.active.crop.bottom,
 977                             front.active.crop.getWidth(),
 978                             front.active.crop.getHeight(),
 979                             front.requested.w, front.requested.h,
 980                             front.requested.crop.left,
 981                             front.requested.crop.top,
 982                             front.requested.crop.right,
 983                             front.requested.crop.bottom,
 984                             front.requested.crop.getWidth(),
 985                             front.requested.crop.getHeight());
 986                 }
 987
 988                 if (!isFixedSize) {
 989                     if (front.active.w != bufWidth ||
 990                         front.active.h != bufHeight) {
 991                         // reject this buffer
 992                         return true;
 993                     }
 994                 }
 995
 996                 // if the transparent region has changed (this test is
 997                 // conservative, but that's fine, worst case we're doing
 998                 // a bit of extra work), we latch the new one and we
 999                 // trigger a visible-region recompute.
1000                 if (!front.activeTransparentRegion.isTriviallyEqual(
1001                         front.requestedTransparentRegion)) {
1002                     front.activeTransparentRegion = front.requestedTransparentRegion;
1003
1004                     // We also need to update the current state so that
1005                     // we don't end-up overwriting the drawing state with
1006                     // this stale current state during the next transaction
1007                     //
1008                     // NOTE: We don't need to hold the transaction lock here
1009                     // because State::active is only accessed from this thread.
1010                     current.activeTransparentRegion = front.activeTransparentRegion;
1011
1012                     // recompute visible region
1013                     recomputeVisibleRegions = true;
1014                 }
1015
1016                 return false;
1017             }
1018         };
1019
1020
1021         Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions);
1022
1023         status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r);
1024         if (updateResult == BufferQueue::PRESENT_LATER) {
1025             // Producer doesn't want buffer to be displayed yet.  Signal a
1026             // layer update so we check again at the next opportunity.
1027             mFlinger->signalLayerUpdate();
1028             return outDirtyRegion;
1029         }
1030
1031         // Decrement the queued-frames count.  Signal another event if we
1032         // have more frames pending.
1033         if (android_atomic_dec(&mQueuedFrames) > 1) {
1034             mFlinger->signalLayerUpdate();
1035         }
1036
1037         if (updateResult != NO_ERROR) {
1038             // something happened!
1039             recomputeVisibleRegions = true;
1040             return outDirtyRegion;
1041         }
1042
1043         // update the active buffer
1044         mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer();
1045         if (mActiveBuffer == NULL) {
1046             // this can only happen if the very first buffer was rejected.
1047             return outDirtyRegion;
1048         }
1049
1050         mRefreshPending = true;
1051         mFrameLatencyNeeded = true;
1052         if (oldActiveBuffer == NULL) {
1053              // the first time we receive a buffer, we need to trigger a
1054              // geometry invalidation.
1055             recomputeVisibleRegions = true;
1056          }
1057
1058         Rect crop(mSurfaceFlingerConsumer->getCurrentCrop());
1059         const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform());
1060         const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode());
1061         if ((crop != mCurrentCrop) ||
1062             (transform != mCurrentTransform) ||
1063             (scalingMode != mCurrentScalingMode))
1064         {
1065             mCurrentCrop = crop;
1066             mCurrentTransform = transform;
1067             mCurrentScalingMode = scalingMode;
1068             recomputeVisibleRegions = true;
1069         }
1070
1071         if (oldActiveBuffer != NULL) {
1072             uint32_t bufWidth  = mActiveBuffer->getWidth();
1073             uint32_t bufHeight = mActiveBuffer->getHeight();
1074             if (bufWidth != uint32_t(oldActiveBuffer->width) ||
1075                 bufHeight != uint32_t(oldActiveBuffer->height)) {
1076                 recomputeVisibleRegions = true;
1077             }
1078         }
1079
1080         mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format);
1081         if (oldOpacity != isOpaque()) {
1082             recomputeVisibleRegions = true;
1083         }
1084
1085         // FIXME: postedRegion should be dirty & bounds
1086         const Layer::State& s(getDrawingState());
1087         Region dirtyRegion(Rect(s.active.w, s.active.h));
1088
1089         // transform the dirty region to window-manager space
1090         outDirtyRegion = (s.transform.transform(dirtyRegion));
1091     }
1092     return outDirtyRegion;
1093 }
1094
1095 uint32_t Layer::getEffectiveUsage(uint32_t usage) const
1096 {
1097     // TODO: should we do something special if mSecure is set?
1098     if (mProtectedByApp) {
1099         // need a hardware-protected path to external video sink
1100         usage |= GraphicBuffer::USAGE_PROTECTED;
1101     }
1102     usage |= GraphicBuffer::USAGE_HW_COMPOSER;
1103     return usage;
1104 }
1105
1106 void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const {
1107     uint32_t orientation = 0;
1108     if (!mFlinger->mDebugDisableTransformHint) {
1109         // The transform hint is used to improve performance, but we can
1110         // only have a single transform hint, it cannot
1111         // apply to all displays.
1112         const Transform& planeTransform(hw->getTransform());
1113         orientation = planeTransform.getOrientation();
1114         if (orientation & Transform::ROT_INVALID) {
1115             orientation = 0;
1116         }
1117     }
1118     mSurfaceFlingerConsumer->setTransformHint(orientation);
1119 }
1120
1121 // ----------------------------------------------------------------------------
1122 // debugging
1123 // ----------------------------------------------------------------------------
1124
1125 void Layer::dump(String8& result, Colorizer& colorizer) const
1126 {
1127     const Layer::State& s(getDrawingState());
1128
1129     colorizer.colorize(result, Colorizer::GREEN);
1130     result.appendFormat(
1131             "+ %s %p (%s)\n",
1132             getTypeId(), this, getName().string());
1133     colorizer.reset(result);
1134
1135     s.activeTransparentRegion.dump(result, "transparentRegion");
1136     visibleRegion.dump(result, "visibleRegion");
1137     sp<Client> client(mClientRef.promote());
1138
1139     result.appendFormat(            "      "
1140             "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), "
1141             "isOpaque=%1d, invalidate=%1d, "
1142             "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n"
1143             "      client=%p\n",
1144             s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h,
1145             s.active.crop.left, s.active.crop.top,
1146             s.active.crop.right, s.active.crop.bottom,
1147             isOpaque(), contentDirty,
1148             s.alpha, s.flags,
1149             s.transform[0][0], s.transform[0][1],
1150             s.transform[1][0], s.transform[1][1],
1151             client.get());
1152
1153     sp<const GraphicBuffer> buf0(mActiveBuffer);
1154     uint32_t w0=0, h0=0, s0=0, f0=0;
1155     if (buf0 != 0) {
1156         w0 = buf0->getWidth();
1157         h0 = buf0->getHeight();
1158         s0 = buf0->getStride();
1159         f0 = buf0->format;
1160     }
1161     result.appendFormat(
1162             "      "
1163             "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X],"
1164             " queued-frames=%d, mRefreshPending=%d\n",
1165             mFormat, w0, h0, s0,f0,
1166             mQueuedFrames, mRefreshPending);
1167
1168     if (mSurfaceFlingerConsumer != 0) {
1169         mSurfaceFlingerConsumer->dump(result, "            ");
1170     }
1171 }
1172
1173 void Layer::dumpStats(String8& result) const {
1174     mFrameTracker.dump(result);
1175 }
1176
1177 void Layer::clearStats() {
1178     mFrameTracker.clear();
1179 }
1180
1181 void Layer::logFrameStats() {
1182     mFrameTracker.logAndResetStats(mName);
1183 }
1184
1185 // ---------------------------------------------------------------------------
1186
1187 Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger,
1188         const sp<Layer>& layer)
1189     : mFlinger(flinger), mLayer(layer) {
1190 }
1191
1192 Layer::LayerCleaner::~LayerCleaner() {
1193     // destroy client resources
1194     mFlinger->onLayerDestroyed(mLayer);
1195 }
1196
1197 // ---------------------------------------------------------------------------
1198
1199
1200 }; // namespace android