frameworks/base/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::draw(const Region& clip) const
 305 {
 306     // reset GL state
 307     glEnable(GL_SCISSOR_TEST);
 308
 309     onDraw(clip);
 310 }
 311
 312 void LayerBase::drawForSreenShot() const
 313 {
 314     const DisplayHardware& hw(graphicPlane(0).displayHardware());
 315     onDraw( Region(hw.bounds()) );
 316 }
 317
 318 void LayerBase::clearWithOpenGL(const Region& clip, GLclampf red,
 319                                 GLclampf green, GLclampf blue,
 320                                 GLclampf alpha) const
 321 {
 322     const DisplayHardware& hw(graphicPlane(0).displayHardware());
 323     const uint32_t fbHeight = hw.getHeight();
 324     glColor4f(red,green,blue,alpha);
 325
 326     TextureManager::deactivateTextures();
 327
 328     glDisable(GL_BLEND);
 329     glDisable(GL_DITHER);
 330
 331     Region::const_iterator it = clip.begin();
 332     Region::const_iterator const end = clip.end();
 333     glEnable(GL_SCISSOR_TEST);
 334     glVertexPointer(2, GL_FLOAT, 0, mVertices);
 335     while (it != end) {
 336         const Rect& r = *it++;
 337         const GLint sy = fbHeight - (r.top + r.height());
 338         glScissor(r.left, sy, r.width(), r.height());
 339         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 340     }
 341 }
 342
 343 void LayerBase::clearWithOpenGL(const Region& clip) const
 344 {
 345     clearWithOpenGL(clip,0,0,0,0);
 346 }
 347
 348 template <typename T>
 349 static inline
 350 void swap(T& a, T& b) {
 351     T t(a);
 352     a = b;
 353     b = t;
 354 }
 355
 356 void LayerBase::drawWithOpenGL(const Region& clip, const Texture& texture) const
 357 {
 358     const DisplayHardware& hw(graphicPlane(0).displayHardware());
 359     const uint32_t fbHeight = hw.getHeight();
 360     const State& s(drawingState());
 361
 362     // bind our texture
 363     TextureManager::activateTexture(texture, needsFiltering());
 364     uint32_t width  = texture.width;
 365     uint32_t height = texture.height;
 366
 367     GLenum src = mPremultipliedAlpha ? GL_ONE : GL_SRC_ALPHA;
 368     if (UNLIKELY(s.alpha < 0xFF)) {
 369         const GLfloat alpha = s.alpha * (1.0f/255.0f);
 370         if (mPremultipliedAlpha) {
 371             glColor4f(alpha, alpha, alpha, alpha);
 372         } else {
 373             glColor4f(1, 1, 1, alpha);
 374         }
 375         glEnable(GL_BLEND);
 376         glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
 377         glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 378     } else {
 379         glColor4f(1, 1, 1, 1);
 380         glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 381         if (needsBlending()) {
 382             glEnable(GL_BLEND);
 383             glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
 384         } else {
 385             glDisable(GL_BLEND);
 386         }
 387     }
 388
 389     /*
 390      *  compute texture coordinates
 391      *  here, we handle NPOT, cropping and buffer transformations
 392      */
 393
 394     GLfloat cl, ct, cr, cb;
 395     if (!mBufferCrop.isEmpty()) {
 396         // source is cropped
 397         const GLfloat us = (texture.NPOTAdjust ? texture.wScale : 1.0f) / width;
 398         const GLfloat vs = (texture.NPOTAdjust ? texture.hScale : 1.0f) / height;
 399         cl = mBufferCrop.left   * us;
 400         ct = mBufferCrop.top    * vs;
 401         cr = mBufferCrop.right  * us;
 402         cb = mBufferCrop.bottom * vs;
 403     } else {
 404         cl = 0;
 405         ct = 0;
 406         cr = (texture.NPOTAdjust ? texture.wScale : 1.0f);
 407         cb = (texture.NPOTAdjust ? texture.hScale : 1.0f);
 408     }
 409
 410     /*
 411      * For the buffer transformation, we apply the rotation last.
 412      * Since we're transforming the texture-coordinates, we need
 413      * to apply the inverse of the buffer transformation:
 414      *   inverse( FLIP_V -> FLIP_H -> ROT_90 )
 415      *   <=> inverse( ROT_90 * FLIP_H * FLIP_V )
 416      *    =  inverse(FLIP_V) * inverse(FLIP_H) * inverse(ROT_90)
 417      *    =  FLIP_V * FLIP_H * ROT_270
 418      *   <=> ROT_270 -> FLIP_H -> FLIP_V
 419      *
 420      * The rotation is performed first, in the texture coordinate space.
 421      *
 422      */
 423
 424     struct TexCoords {
 425         GLfloat u;
 426         GLfloat v;
 427     };
 428
 429     enum {
 430         // name of the corners in the texture map
 431         LB = 0, // left-bottom
 432         LT = 1, // left-top
 433         RT = 2, // right-top
 434         RB = 3  // right-bottom
 435     };
 436
 437     // vertices in screen space
 438     int vLT = LB;
 439     int vLB = LT;
 440     int vRB = RT;
 441     int vRT = RB;
 442
 443     // the texture's source is rotated
 444     uint32_t transform = mBufferTransform;
 445     if (transform & HAL_TRANSFORM_ROT_90) {
 446         vLT = RB;
 447         vLB = LB;
 448         vRB = LT;
 449         vRT = RT;
 450     }
 451     if (transform & HAL_TRANSFORM_FLIP_V) {
 452         swap(vLT, vLB);
 453         swap(vRT, vRB);
 454     }
 455     if (transform & HAL_TRANSFORM_FLIP_H) {
 456         swap(vLT, vRT);
 457         swap(vLB, vRB);
 458     }
 459
 460     TexCoords texCoords[4];
 461     texCoords[vLT].u = cl;
 462     texCoords[vLT].v = ct;
 463     texCoords[vLB].u = cl;
 464     texCoords[vLB].v = cb;
 465     texCoords[vRB].u = cr;
 466     texCoords[vRB].v = cb;
 467     texCoords[vRT].u = cr;
 468     texCoords[vRT].v = ct;
 469
 470     if (needsDithering()) {
 471         glEnable(GL_DITHER);
 472     } else {
 473         glDisable(GL_DITHER);
 474     }
 475
 476     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 477     glVertexPointer(2, GL_FLOAT, 0, mVertices);
 478     glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
 479
 480     Region::const_iterator it = clip.begin();
 481     Region::const_iterator const end = clip.end();
 482     while (it != end) {
 483         const Rect& r = *it++;
 484         const GLint sy = fbHeight - (r.top + r.height());
 485         glScissor(r.left, sy, r.width(), r.height());
 486         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 487     }
 488     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 489 }
 490
 491 void LayerBase::setBufferCrop(const Rect& crop) {
 492     if (!crop.isEmpty()) {
 493         mBufferCrop = crop;
 494     }
 495 }
 496
 497 void LayerBase::setBufferTransform(uint32_t transform) {
 498     mBufferTransform = transform;
 499 }
 500
 501 void LayerBase::dump(String8& result, char* buffer, size_t SIZE) const
 502 {
 503     const Layer::State& s(drawingState());
 504     snprintf(buffer, SIZE,
 505             "+ %s %p\n"
 506             "      "
 507             "z=%9d, pos=(%4d,%4d), size=(%4d,%4d), "
 508             "needsBlending=%1d, needsDithering=%1d, invalidate=%1d, "
 509             "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n",
 510             getTypeId(), this, s.z, tx(), ty(), s.w, s.h,
 511             needsBlending(), needsDithering(), contentDirty,
 512             s.alpha, s.flags,
 513             s.transform[0][0], s.transform[0][1],
 514             s.transform[1][0], s.transform[1][1]);
 515     result.append(buffer);
 516 }
 517
 518 void LayerBase::shortDump(String8& result, char* scratch, size_t size) const
 519 {
 520     LayerBase::dump(result, scratch, size);
 521 }
 522
 523
 524 // ---------------------------------------------------------------------------
 525
 526 int32_t LayerBaseClient::sIdentity = 1;
 527
 528 LayerBaseClient::LayerBaseClient(SurfaceFlinger* flinger, DisplayID display,
 529         const sp<Client>& client)
 530     : LayerBase(flinger, display), mClientRef(client),
 531       mIdentity(uint32_t(android_atomic_inc(&sIdentity)))
 532 {
 533 }
 534
 535 LayerBaseClient::~LayerBaseClient()
 536 {
 537     sp<Client> c(mClientRef.promote());
 538     if (c != 0) {
 539         c->detachLayer(this);
 540     }
 541 }
 542
 543 sp<LayerBaseClient::Surface> LayerBaseClient::getSurface()
 544 {
 545     sp<Surface> s;
 546     Mutex::Autolock _l(mLock);
 547     s = mClientSurface.promote();
 548     if (s == 0) {
 549         s = createSurface();
 550         mClientSurface = s;
 551     }
 552     return s;
 553 }
 554
 555 sp<LayerBaseClient::Surface> LayerBaseClient::createSurface() const
 556 {
 557     return new Surface(mFlinger, mIdentity,
 558             const_cast<LayerBaseClient *>(this));
 559 }
 560
 561 void LayerBaseClient::dump(String8& result, char* buffer, size_t SIZE) const
 562 {
 563     LayerBase::dump(result, buffer, SIZE);
 564
 565     sp<Client> client(mClientRef.promote());
 566     snprintf(buffer, SIZE,
 567             "      name=%s\n"
 568             "      client=%p, identity=%u\n",
 569             getName().string(),
 570             client.get(), getIdentity());
 571
 572     result.append(buffer);
 573 }
 574
 575
 576 void LayerBaseClient::shortDump(String8& result, char* scratch, size_t size) const
 577 {
 578     LayerBaseClient::dump(result, scratch, size);
 579 }
 580
 581 // ---------------------------------------------------------------------------
 582
 583 LayerBaseClient::Surface::Surface(
 584         const sp<SurfaceFlinger>& flinger,
 585         int identity,
 586         const sp<LayerBaseClient>& owner)
 587     : mFlinger(flinger), mIdentity(identity), mOwner(owner)
 588 {
 589 }
 590
 591 LayerBaseClient::Surface::~Surface()
 592 {
 593     /*
 594      * This is a good place to clean-up all client resources
 595      */
 596
 597     // destroy client resources
 598     sp<LayerBaseClient> layer = getOwner();
 599     if (layer != 0) {
 600         mFlinger->destroySurface(layer);
 601     }
 602 }
 603
 604 sp<LayerBaseClient> LayerBaseClient::Surface::getOwner() const {
 605     sp<LayerBaseClient> owner(mOwner.promote());
 606     return owner;
 607 }
 608
 609 status_t LayerBaseClient::Surface::onTransact(
 610         uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
 611 {
 612     switch (code) {
 613         case REGISTER_BUFFERS:
 614         case UNREGISTER_BUFFERS:
 615         case CREATE_OVERLAY:
 616         {
 617             if (!mFlinger->mAccessSurfaceFlinger.checkCalling()) {
 618                 IPCThreadState* ipc = IPCThreadState::self();
 619                 const int pid = ipc->getCallingPid();
 620                 const int uid = ipc->getCallingUid();
 621                 LOGE("Permission Denial: "
 622                         "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
 623                 return PERMISSION_DENIED;
 624             }
 625         }
 626     }
 627     return BnSurface::onTransact(code, data, reply, flags);
 628 }
 629
 630 sp<GraphicBuffer> LayerBaseClient::Surface::requestBuffer(int bufferIdx,
 631         uint32_t w, uint32_t h, uint32_t format, uint32_t usage)
 632 {
 633     return NULL;
 634 }
 635
 636 status_t LayerBaseClient::Surface::setBufferCount(int bufferCount)
 637 {
 638     return INVALID_OPERATION;
 639 }
 640
 641 status_t LayerBaseClient::Surface::registerBuffers(
 642         const ISurface::BufferHeap& buffers)
 643 {
 644     return INVALID_OPERATION;
 645 }
 646
 647 void LayerBaseClient::Surface::postBuffer(ssize_t offset)
 648 {
 649 }
 650
 651 void LayerBaseClient::Surface::unregisterBuffers()
 652 {
 653 }
 654
 655 sp<OverlayRef> LayerBaseClient::Surface::createOverlay(
 656         uint32_t w, uint32_t h, int32_t format, int32_t orientation)
 657 {
 658     return NULL;
 659 };
 660
 661 // ---------------------------------------------------------------------------
 662
 663 }; // namespace android