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