services/surfaceflinger/LayerBase.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 #include <stdlib.h>
  18 #include <stdint.h>
  19 #include <sys/types.h>
  20
  21 #include <utils/Errors.h>
  22 #include <utils/Log.h>
  23 #include <binder/IPCThreadState.h>
  24 #include <binder/IServiceManager.h>
  25
  26 #include <GLES/gl.h>
  27 #include <GLES/glext.h>
  28
  29 #include <hardware/hardware.h>
  30
  31 #include "clz.h"
  32 #include "LayerBase.h"
  33 #include "SurfaceFlinger.h"
  34 #include "DisplayHardware/DisplayHardware.h"
  35 #include "TextureManager.h"
  36
  37
  38 namespace android {
  39
  40 // ---------------------------------------------------------------------------
  41
  42 int32_t LayerBase::sSequence = 1;
  43
  44 LayerBase::LayerBase(SurfaceFlinger* flinger, DisplayID display)
  45     : dpy(display), contentDirty(false),
  46       sequence(uint32_t(android_atomic_inc(&sSequence))),
  47       mFlinger(flinger),
  48       mNeedsFiltering(false),
  49       mOrientation(0),
  50       mLeft(0), mTop(0),
  51       mTransactionFlags(0),
  52       mPremultipliedAlpha(true), mName("unnamed"), mDebug(false),
  53       mInvalidate(0)
  54 {
  55     const DisplayHardware& hw(flinger->graphicPlane(0).displayHardware());
  56     mFlags = hw.getFlags();
  57     mBufferCrop.makeInvalid();
  58     mBufferTransform = 0;
  59 }
  60
  61 LayerBase::~LayerBase()
  62 {
  63 }
  64
  65 void LayerBase::setName(const String8& name) {
  66     mName = name;
  67 }
  68
  69 String8 LayerBase::getName() const {
  70     return mName;
  71 }
  72
  73 const GraphicPlane& LayerBase::graphicPlane(int dpy) const
  74 {
  75     return mFlinger->graphicPlane(dpy);
  76 }
  77
  78 GraphicPlane& LayerBase::graphicPlane(int dpy)
  79 {
  80     return mFlinger->graphicPlane(dpy);
  81 }
  82
  83 void LayerBase::initStates(uint32_t w, uint32_t h, uint32_t flags)
  84 {
  85     uint32_t layerFlags = 0;
  86     if (flags & ISurfaceComposer::eHidden)
  87         layerFlags = ISurfaceComposer::eLayerHidden;
  88
  89     if (flags & ISurfaceComposer::eNonPremultiplied)
  90         mPremultipliedAlpha = false;
  91
  92     mCurrentState.z             = 0;
  93     mCurrentState.w             = w;
  94     mCurrentState.h             = h;
  95     mCurrentState.requested_w   = w;
  96     mCurrentState.requested_h   = h;
  97     mCurrentState.alpha         = 0xFF;
  98     mCurrentState.flags         = layerFlags;
  99     mCurrentState.sequence      = 0;
 100     mCurrentState.transform.set(0, 0);
 101
 102     // drawing state & current state are identical
 103     mDrawingState = mCurrentState;
 104 }
 105
 106 void LayerBase::commitTransaction() {
 107     mDrawingState = mCurrentState;
 108 }
 109 void LayerBase::forceVisibilityTransaction() {
 110     // this can be called without SurfaceFlinger.mStateLock, but if we
 111     // can atomically increment the sequence number, it doesn't matter.
 112     android_atomic_inc(&mCurrentState.sequence);
 113     requestTransaction();
 114 }
 115 bool LayerBase::requestTransaction() {
 116     int32_t old = setTransactionFlags(eTransactionNeeded);
 117     return ((old & eTransactionNeeded) == 0);
 118 }
 119 uint32_t LayerBase::getTransactionFlags(uint32_t flags) {
 120     return android_atomic_and(~flags, &mTransactionFlags) & flags;
 121 }
 122 uint32_t LayerBase::setTransactionFlags(uint32_t flags) {
 123     return android_atomic_or(flags, &mTransactionFlags);
 124 }
 125
 126 bool LayerBase::setPosition(int32_t x, int32_t y) {
 127     if (mCurrentState.transform.tx() == x && mCurrentState.transform.ty() == y)
 128         return false;
 129     mCurrentState.sequence++;
 130     mCurrentState.transform.set(x, y);
 131     requestTransaction();
 132     return true;
 133 }
 134 bool LayerBase::setLayer(uint32_t z) {
 135     if (mCurrentState.z == z)
 136         return false;
 137     mCurrentState.sequence++;
 138     mCurrentState.z = z;
 139     requestTransaction();
 140     return true;
 141 }
 142 bool LayerBase::setSize(uint32_t w, uint32_t h) {
 143     if (mCurrentState.requested_w == w && mCurrentState.requested_h == h)
 144         return false;
 145     mCurrentState.requested_w = w;
 146     mCurrentState.requested_h = h;
 147     requestTransaction();
 148     return true;
 149 }
 150 bool LayerBase::setAlpha(uint8_t alpha) {
 151     if (mCurrentState.alpha == alpha)
 152         return false;
 153     mCurrentState.sequence++;
 154     mCurrentState.alpha = alpha;
 155     requestTransaction();
 156     return true;
 157 }
 158 bool LayerBase::setMatrix(const layer_state_t::matrix22_t& matrix) {
 159     mCurrentState.sequence++;
 160     mCurrentState.transform.set(
 161             matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy);
 162     requestTransaction();
 163     return true;
 164 }
 165 bool LayerBase::setTransparentRegionHint(const Region& transparent) {
 166     mCurrentState.sequence++;
 167     mCurrentState.transparentRegion = transparent;
 168     requestTransaction();
 169     return true;
 170 }
 171 bool LayerBase::setFlags(uint8_t flags, uint8_t mask) {
 172     const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask);
 173     if (mCurrentState.flags == newFlags)
 174         return false;
 175     mCurrentState.sequence++;
 176     mCurrentState.flags = newFlags;
 177     requestTransaction();
 178     return true;
 179 }
 180
 181 Rect LayerBase::visibleBounds() const
 182 {
 183     return mTransformedBounds;
 184 }
 185
 186 void LayerBase::setVisibleRegion(const Region& visibleRegion) {
 187     // always called from main thread
 188     visibleRegionScreen = visibleRegion;
 189 }
 190
 191 void LayerBase::setCoveredRegion(const Region& coveredRegion) {
 192     // always called from main thread
 193     coveredRegionScreen = coveredRegion;
 194 }
 195
 196 uint32_t LayerBase::doTransaction(uint32_t flags)
 197 {
 198     const Layer::State& front(drawingState());
 199     const Layer::State& temp(currentState());
 200
 201     if ((front.requested_w != temp.requested_w) ||
 202         (front.requested_h != temp.requested_h))  {
 203         // resize the layer, set the physical size to the requested size
 204         Layer::State& editTemp(currentState());
 205         editTemp.w = temp.requested_w;
 206         editTemp.h = temp.requested_h;
 207     }
 208
 209     if ((front.w != temp.w) || (front.h != temp.h)) {
 210         // invalidate and recompute the visible regions if needed
 211         flags |= Layer::eVisibleRegion;
 212     }
 213
 214     if (temp.sequence != front.sequence) {
 215         // invalidate and recompute the visible regions if needed
 216         flags |= eVisibleRegion;
 217         this->contentDirty = true;
 218
 219         // we may use linear filtering, if the matrix scales us
 220         const uint8_t type = temp.transform.getType();
 221         mNeedsFiltering = (!temp.transform.preserveRects() ||
 222                 (type >= Transform::SCALE));
 223     }
 224
 225     // Commit the transaction
 226     commitTransaction();
 227     return flags;
 228 }
 229
 230 void LayerBase::validateVisibility(const Transform& planeTransform)
 231 {
 232     const Layer::State& s(drawingState());
 233     const Transform tr(planeTransform * s.transform);
 234     const bool transformed = tr.transformed();
 235
 236     uint32_t w = s.w;
 237     uint32_t h = s.h;
 238     tr.transform(mVertices[0], 0, 0);
 239     tr.transform(mVertices[1], 0, h);
 240     tr.transform(mVertices[2], w, h);
 241     tr.transform(mVertices[3], w, 0);
 242     if (UNLIKELY(transformed)) {
 243         // NOTE: here we could also punt if we have too many rectangles
 244         // in the transparent region
 245         if (tr.preserveRects()) {
 246             // transform the transparent region
 247             transparentRegionScreen = tr.transform(s.transparentRegion);
 248         } else {
 249             // transformation too complex, can't do the transparent region
 250             // optimization.
 251             transparentRegionScreen.clear();
 252         }
 253     } else {
 254         transparentRegionScreen = s.transparentRegion;
 255     }
 256
 257     // cache a few things...
 258     mOrientation = tr.getOrientation();
 259     mTransformedBounds = tr.makeBounds(w, h);
 260     mLeft = tr.tx();
 261     mTop  = tr.ty();
 262 }
 263
 264 void LayerBase::lockPageFlip(bool& recomputeVisibleRegions)
 265 {
 266 }
 267
 268 void LayerBase::unlockPageFlip(
 269         const Transform& planeTransform, Region& outDirtyRegion)
 270 {
 271     if ((android_atomic_and(~1, &mInvalidate)&1) == 1) {
 272         outDirtyRegion.orSelf(visibleRegionScreen);
 273     }
 274 }
 275
 276 void LayerBase::invalidate()
 277 {
 278     if ((android_atomic_or(1, &mInvalidate)&1) == 0) {
 279         mFlinger->signalEvent();
 280     }
 281 }
 282
 283 void LayerBase::drawRegion(const Region& reg) const
 284 {
 285     Region::const_iterator it = reg.begin();
 286     Region::const_iterator const end = reg.end();
 287     if (it != end) {
 288         Rect r;
 289         const DisplayHardware& hw(graphicPlane(0).displayHardware());
 290         const int32_t fbWidth  = hw.getWidth();
 291         const int32_t fbHeight = hw.getHeight();
 292         const GLshort vertices[][2] = { { 0, 0 }, { fbWidth, 0 },
 293                 { fbWidth, fbHeight }, { 0, fbHeight }  };
 294         glVertexPointer(2, GL_SHORT, 0, vertices);
 295         while (it != end) {
 296             const Rect& r = *it++;
 297             const GLint sy = fbHeight - (r.top + r.height());
 298             glScissor(r.left, sy, r.width(), r.height());
 299             glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 300         }
 301     }
 302 }
 303
 304 void LayerBase::setGeometry(hwc_layer_t* hwcl) {
 305     hwcl->flags |= HWC_SKIP_LAYER;
 306 }
 307
 308 void LayerBase::setPerFrameData(hwc_layer_t* hwcl) {
 309     hwcl->compositionType = HWC_FRAMEBUFFER;
 310     hwcl->handle = NULL;
 311 }
 312
 313 void LayerBase::draw(const Region& clip) const
 314 {
 315     // reset GL state
 316     glEnable(GL_SCISSOR_TEST);
 317
 318     onDraw(clip);
 319 }
 320
 321 void LayerBase::drawForSreenShot() const
 322 {
 323     const DisplayHardware& hw(graphicPlane(0).displayHardware());
 324     onDraw( Region(hw.bounds()) );
 325 }
 326
 327 void LayerBase::clearWithOpenGL(const Region& clip, GLclampf red,
 328                                 GLclampf green, GLclampf blue,
 329                                 GLclampf alpha) const
 330 {
 331     const DisplayHardware& hw(graphicPlane(0).displayHardware());
 332     const uint32_t fbHeight = hw.getHeight();
 333     glColor4f(red,green,blue,alpha);
 334
 335     TextureManager::deactivateTextures();
 336
 337     glDisable(GL_BLEND);
 338     glDisable(GL_DITHER);
 339
 340     Region::const_iterator it = clip.begin();
 341     Region::const_iterator const end = clip.end();
 342     glEnable(GL_SCISSOR_TEST);
 343     glVertexPointer(2, GL_FLOAT, 0, mVertices);
 344     while (it != end) {
 345         const Rect& r = *it++;
 346         const GLint sy = fbHeight - (r.top + r.height());
 347         glScissor(r.left, sy, r.width(), r.height());
 348         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 349     }
 350 }
 351
 352 void LayerBase::clearWithOpenGL(const Region& clip) const
 353 {
 354     clearWithOpenGL(clip,0,0,0,0);
 355 }
 356
 357 template <typename T>
 358 static inline
 359 void swap(T& a, T& b) {
 360     T t(a);
 361     a = b;
 362     b = t;
 363 }
 364
 365 void LayerBase::drawWithOpenGL(const Region& clip, const Texture& texture) const
 366 {
 367     const DisplayHardware& hw(graphicPlane(0).displayHardware());
 368     const uint32_t fbHeight = hw.getHeight();
 369     const State& s(drawingState());
 370
 371     // bind our texture
 372     TextureManager::activateTexture(texture, needsFiltering());
 373     uint32_t width  = texture.width;
 374     uint32_t height = texture.height;
 375
 376     GLenum src = mPremultipliedAlpha ? GL_ONE : GL_SRC_ALPHA;
 377     if (UNLIKELY(s.alpha < 0xFF)) {
 378         const GLfloat alpha = s.alpha * (1.0f/255.0f);
 379         if (mPremultipliedAlpha) {
 380             glColor4f(alpha, alpha, alpha, alpha);
 381         } else {
 382             glColor4f(1, 1, 1, alpha);
 383         }
 384         glEnable(GL_BLEND);
 385         glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
 386         glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 387     } else {
 388         glColor4f(1, 1, 1, 1);
 389         glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 390         if (needsBlending()) {
 391             glEnable(GL_BLEND);
 392             glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
 393         } else {
 394             glDisable(GL_BLEND);
 395         }
 396     }
 397
 398     /*
 399      *  compute texture coordinates
 400      *  here, we handle NPOT, cropping and buffer transformations
 401      */
 402
 403     GLfloat cl, ct, cr, cb;
 404     if (!mBufferCrop.isEmpty()) {
 405         // source is cropped
 406         const GLfloat us = (texture.NPOTAdjust ? texture.wScale : 1.0f) / width;
 407         const GLfloat vs = (texture.NPOTAdjust ? texture.hScale : 1.0f) / height;
 408         cl = mBufferCrop.left   * us;
 409         ct = mBufferCrop.top    * vs;
 410         cr = mBufferCrop.right  * us;
 411         cb = mBufferCrop.bottom * vs;
 412     } else {
 413         cl = 0;
 414         ct = 0;
 415         cr = (texture.NPOTAdjust ? texture.wScale : 1.0f);
 416         cb = (texture.NPOTAdjust ? texture.hScale : 1.0f);
 417     }
 418
 419     /*
 420      * For the buffer transformation, we apply the rotation last.
 421      * Since we're transforming the texture-coordinates, we need
 422      * to apply the inverse of the buffer transformation:
 423      *   inverse( FLIP_V -> FLIP_H -> ROT_90 )
 424      *   <=> inverse( ROT_90 * FLIP_H * FLIP_V )
 425      *    =  inverse(FLIP_V) * inverse(FLIP_H) * inverse(ROT_90)
 426      *    =  FLIP_V * FLIP_H * ROT_270
 427      *   <=> ROT_270 -> FLIP_H -> FLIP_V
 428      *
 429      * The rotation is performed first, in the texture coordinate space.
 430      *
 431      */
 432
 433     struct TexCoords {
 434         GLfloat u;
 435         GLfloat v;
 436     };
 437
 438     enum {
 439         // name of the corners in the texture map
 440         LB = 0, // left-bottom
 441         LT = 1, // left-top
 442         RT = 2, // right-top
 443         RB = 3  // right-bottom
 444     };
 445
 446     // vertices in screen space
 447     int vLT = LB;
 448     int vLB = LT;
 449     int vRB = RT;
 450     int vRT = RB;
 451
 452     // the texture's source is rotated
 453     uint32_t transform = mBufferTransform;
 454     if (transform & HAL_TRANSFORM_ROT_90) {
 455         vLT = RB;
 456         vLB = LB;
 457         vRB = LT;
 458         vRT = RT;
 459     }
 460     if (transform & HAL_TRANSFORM_FLIP_V) {
 461         swap(vLT, vLB);
 462         swap(vRT, vRB);
 463     }
 464     if (transform & HAL_TRANSFORM_FLIP_H) {
 465         swap(vLT, vRT);
 466         swap(vLB, vRB);
 467     }
 468
 469     TexCoords texCoords[4];
 470     texCoords[vLT].u = cl;
 471     texCoords[vLT].v = ct;
 472     texCoords[vLB].u = cl;
 473     texCoords[vLB].v = cb;
 474     texCoords[vRB].u = cr;
 475     texCoords[vRB].v = cb;
 476     texCoords[vRT].u = cr;
 477     texCoords[vRT].v = ct;
 478
 479     if (needsDithering()) {
 480         glEnable(GL_DITHER);
 481     } else {
 482         glDisable(GL_DITHER);
 483     }
 484
 485     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 486     glVertexPointer(2, GL_FLOAT, 0, mVertices);
 487     glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
 488
 489     Region::const_iterator it = clip.begin();
 490     Region::const_iterator const end = clip.end();
 491     while (it != end) {
 492         const Rect& r = *it++;
 493         const GLint sy = fbHeight - (r.top + r.height());
 494         glScissor(r.left, sy, r.width(), r.height());
 495         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 496     }
 497     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 498 }
 499
 500 void LayerBase::setBufferCrop(const Rect& crop) {
 501     if (mBufferCrop != crop) {
 502         mBufferCrop = crop;
 503         mFlinger->invalidateHwcGeometry();
 504     }
 505 }
 506
 507 void LayerBase::setBufferTransform(uint32_t transform) {
 508     if (mBufferTransform != transform) {
 509         mBufferTransform = transform;
 510         mFlinger->invalidateHwcGeometry();
 511     }
 512 }
 513
 514 void LayerBase::dump(String8& result, char* buffer, size_t SIZE) const
 515 {
 516     const Layer::State& s(drawingState());
 517     snprintf(buffer, SIZE,
 518             "+ %s %p\n"
 519             "      "
 520             "z=%9d, pos=(%4d,%4d), size=(%4d,%4d), "
 521             "needsBlending=%1d, needsDithering=%1d, invalidate=%1d, "
 522             "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n",
 523             getTypeId(), this, s.z, tx(), ty(), s.w, s.h,
 524             needsBlending(), needsDithering(), contentDirty,
 525             s.alpha, s.flags,
 526             s.transform[0][0], s.transform[0][1],
 527             s.transform[1][0], s.transform[1][1]);
 528     result.append(buffer);
 529 }
 530
 531 void LayerBase::shortDump(String8& result, char* scratch, size_t size) const
 532 {
 533     LayerBase::dump(result, scratch, size);
 534 }
 535
 536
 537 // ---------------------------------------------------------------------------
 538
 539 int32_t LayerBaseClient::sIdentity = 1;
 540
 541 LayerBaseClient::LayerBaseClient(SurfaceFlinger* flinger, DisplayID display,
 542         const sp<Client>& client)
 543     : LayerBase(flinger, display),
 544       mHasSurface(false),
 545       mClientRef(client),
 546       mIdentity(uint32_t(android_atomic_inc(&sIdentity)))
 547 {
 548 }
 549
 550 LayerBaseClient::~LayerBaseClient()
 551 {
 552     sp<Client> c(mClientRef.promote());
 553     if (c != 0) {
 554         c->detachLayer(this);
 555     }
 556 }
 557
 558 sp<LayerBaseClient::Surface> LayerBaseClient::getSurface()
 559 {
 560     sp<Surface> s;
 561     Mutex::Autolock _l(mLock);
 562
 563     LOG_ALWAYS_FATAL_IF(mHasSurface,
 564             "LayerBaseClient::getSurface() has already been called");
 565
 566     mHasSurface = true;
 567     s = createSurface();
 568     mClientSurfaceBinder = s->asBinder();
 569     return s;
 570 }
 571
 572 wp<IBinder> LayerBaseClient::getSurfaceBinder() const {
 573     return mClientSurfaceBinder;
 574 }
 575
 576 sp<LayerBaseClient::Surface> LayerBaseClient::createSurface() const
 577 {
 578     return new Surface(mFlinger, mIdentity,
 579             const_cast<LayerBaseClient *>(this));
 580 }
 581
 582 void LayerBaseClient::dump(String8& result, char* buffer, size_t SIZE) const
 583 {
 584     LayerBase::dump(result, buffer, SIZE);
 585
 586     sp<Client> client(mClientRef.promote());
 587     snprintf(buffer, SIZE,
 588             "      name=%s\n"
 589             "      client=%p, identity=%u\n",
 590             getName().string(),
 591             client.get(), getIdentity());
 592
 593     result.append(buffer);
 594 }
 595
 596
 597 void LayerBaseClient::shortDump(String8& result, char* scratch, size_t size) const
 598 {
 599     LayerBaseClient::dump(result, scratch, size);
 600 }
 601
 602 // ---------------------------------------------------------------------------
 603
 604 LayerBaseClient::Surface::Surface(
 605         const sp<SurfaceFlinger>& flinger,
 606         int identity,
 607         const sp<LayerBaseClient>& owner)
 608     : mFlinger(flinger), mIdentity(identity), mOwner(owner)
 609 {
 610 }
 611
 612 LayerBaseClient::Surface::~Surface()
 613 {
 614     /*
 615      * This is a good place to clean-up all client resources
 616      */
 617
 618     // destroy client resources
 619     sp<LayerBaseClient> layer = getOwner();
 620     if (layer != 0) {
 621         mFlinger->destroySurface(layer);
 622     }
 623 }
 624
 625 sp<LayerBaseClient> LayerBaseClient::Surface::getOwner() const {
 626     sp<LayerBaseClient> owner(mOwner.promote());
 627     return owner;
 628 }
 629
 630 status_t LayerBaseClient::Surface::onTransact(
 631         uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
 632 {
 633     return BnSurface::onTransact(code, data, reply, flags);
 634 }
 635
 636 sp<GraphicBuffer> LayerBaseClient::Surface::requestBuffer(int bufferIdx,
 637         uint32_t w, uint32_t h, uint32_t format, uint32_t usage)
 638 {
 639     return NULL;
 640 }
 641
 642 status_t LayerBaseClient::Surface::setBufferCount(int bufferCount)
 643 {
 644     return INVALID_OPERATION;
 645 }
 646
 647 // ---------------------------------------------------------------------------
 648
 649 }; // namespace android