Home | History | Annotate | Download | only in android 
      1 /*
      2  * Copyright 2010, The Android Open Source Project
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  *  * Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  *  * Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #define LOG_TAG "GLWebViewState"
     27 #define LOG_NDEBUG 1
     28 
     29 #include "config.h"
     30 #include "GLWebViewState.h"
     31 
     32 #if USE(ACCELERATED_COMPOSITING)
     33 
     34 #include "AndroidLog.h"
     35 #include "BaseLayerAndroid.h"
     36 #include "ClassTracker.h"
     37 #include "GLUtils.h"
     38 #include "ImagesManager.h"
     39 #include "LayerAndroid.h"
     40 #include "private/hwui/DrawGlInfo.h"
     41 #include "ScrollableLayerAndroid.h"
     42 #include "SkPath.h"
     43 #include "TilesManager.h"
     44 #include "TransferQueue.h"
     45 #include "SurfaceCollection.h"
     46 #include "SurfaceCollectionManager.h"
     47 #include <pthread.h>
     48 #include <wtf/CurrentTime.h>
     49 
     50 // log warnings if scale goes outside this range
     51 #define MIN_SCALE_WARNING 0.1
     52 #define MAX_SCALE_WARNING 10
     53 
     54 // fps indicator is FPS_INDICATOR_HEIGHT pixels high.
     55 // The max width is equal to MAX_FPS_VALUE fps.
     56 #define FPS_INDICATOR_HEIGHT 10
     57 #define MAX_FPS_VALUE 60
     58 
     59 #define COLLECTION_SWAPPED_COUNTER_MODULE 10
     60 
     61 namespace WebCore {
     62 
     63 using namespace android::uirenderer;
     64 
     65 GLWebViewState::GLWebViewState()
     66     : m_frameworkLayersInval(0, 0, 0, 0)
     67     , m_doFrameworkFullInval(false)
     68     , m_isScrolling(false)
     69     , m_isVisibleContentRectScrolling(false)
     70     , m_goingDown(true)
     71     , m_goingLeft(false)
     72     , m_scale(1)
     73     , m_layersRenderingMode(kAllTextures)
     74     , m_surfaceCollectionManager()
     75 {
     76     m_visibleContentRect.setEmpty();
     77 
     78 #ifdef DEBUG_COUNT
     79     ClassTracker::instance()->increment("GLWebViewState");
     80 #endif
     81 #ifdef MEASURES_PERF
     82     m_timeCounter = 0;
     83     m_totalTimeCounter = 0;
     84     m_measurePerfs = false;
     85 #endif
     86 }
     87 
     88 GLWebViewState::~GLWebViewState()
     89 {
     90 #ifdef DEBUG_COUNT
     91     ClassTracker::instance()->decrement("GLWebViewState");
     92 #endif
     93 
     94 }
     95 
     96 bool GLWebViewState::setBaseLayer(BaseLayerAndroid* layer, bool showVisualIndicator,
     97                                   bool isPictureAfterFirstLayout)
     98 {
     99     if (!layer || isPictureAfterFirstLayout)
    100         m_layersRenderingMode = kAllTextures;
    101 
    102     SurfaceCollection* collection = 0;
    103     if (layer) {
    104         ALOGV("layer tree %p, with child %p", layer, layer->getChild(0));
    105         layer->setState(this);
    106         collection = new SurfaceCollection(layer);
    107     }
    108     bool queueFull = m_surfaceCollectionManager.updateWithSurfaceCollection(
    109         collection, isPictureAfterFirstLayout);
    110     m_glExtras.setDrawExtra(0);
    111 
    112 #ifdef MEASURES_PERF
    113     if (m_measurePerfs && !showVisualIndicator)
    114         dumpMeasures();
    115     m_measurePerfs = showVisualIndicator;
    116 #endif
    117 
    118     TilesManager::instance()->setShowVisualIndicator(showVisualIndicator);
    119     return queueFull;
    120 }
    121 
    122 void GLWebViewState::scrollLayer(int layerId, int x, int y)
    123 {
    124     m_surfaceCollectionManager.updateScrollableLayer(layerId, x, y);
    125 }
    126 
    127 void GLWebViewState::setVisibleContentRect(const SkRect& visibleContentRect, float scale)
    128 {
    129     // allocate max possible number of tiles visible with this visibleContentRect / expandedTileBounds
    130     const float invTileContentWidth = scale / TilesManager::tileWidth();
    131     const float invTileContentHeight = scale / TilesManager::tileHeight();
    132 
    133     int viewMaxTileX =
    134         static_cast<int>(ceilf((visibleContentRect.width()-1) * invTileContentWidth)) + 1;
    135     int viewMaxTileY =
    136         static_cast<int>(ceilf((visibleContentRect.height()-1) * invTileContentHeight)) + 1;
    137 
    138     TilesManager* tilesManager = TilesManager::instance();
    139     int maxTextureCount = viewMaxTileX * viewMaxTileY * (tilesManager->highEndGfx() ? 4 : 2);
    140 
    141     tilesManager->setCurrentTextureCount(maxTextureCount);
    142 
    143     // TODO: investigate whether we can move this return earlier.
    144     if ((m_visibleContentRect == visibleContentRect)
    145         && (m_scale == scale)) {
    146         // everything below will stay the same, early return.
    147         m_isVisibleContentRectScrolling = false;
    148         return;
    149     }
    150     m_scale = scale;
    151 
    152     m_goingDown = m_visibleContentRect.fTop - visibleContentRect.fTop <= 0;
    153     m_goingLeft = m_visibleContentRect.fLeft - visibleContentRect.fLeft >= 0;
    154 
    155     // detect visibleContentRect scrolling from short programmatic scrolls/jumps
    156     m_isVisibleContentRectScrolling = m_visibleContentRect != visibleContentRect
    157         && SkRect::Intersects(m_visibleContentRect, visibleContentRect);
    158     m_visibleContentRect = visibleContentRect;
    159 
    160     ALOGV("New visibleContentRect %.2f - %.2f %.2f - %.2f (w: %2.f h: %.2f scale: %.2f )",
    161           m_visibleContentRect.fLeft, m_visibleContentRect.fTop,
    162           m_visibleContentRect.fRight, m_visibleContentRect.fBottom,
    163           m_visibleContentRect.width(), m_visibleContentRect.height(), scale);
    164 }
    165 
    166 #ifdef MEASURES_PERF
    167 void GLWebViewState::dumpMeasures()
    168 {
    169     for (int i = 0; i < m_timeCounter; i++) {
    170         ALOGD("%d delay: %d ms", m_totalTimeCounter + i,
    171              static_cast<int>(m_delayTimes[i]*1000));
    172         m_delayTimes[i] = 0;
    173     }
    174     m_totalTimeCounter += m_timeCounter;
    175     m_timeCounter = 0;
    176 }
    177 #endif // MEASURES_PERF
    178 
    179 void GLWebViewState::addDirtyArea(const IntRect& rect)
    180 {
    181     if (rect.isEmpty())
    182         return;
    183 
    184     IntRect inflatedRect = rect;
    185     inflatedRect.inflate(8);
    186     if (m_frameworkLayersInval.isEmpty())
    187         m_frameworkLayersInval = inflatedRect;
    188     else
    189         m_frameworkLayersInval.unite(inflatedRect);
    190 }
    191 
    192 void GLWebViewState::resetLayersDirtyArea()
    193 {
    194     m_frameworkLayersInval.setX(0);
    195     m_frameworkLayersInval.setY(0);
    196     m_frameworkLayersInval.setWidth(0);
    197     m_frameworkLayersInval.setHeight(0);
    198     m_doFrameworkFullInval = false;
    199 }
    200 
    201 void GLWebViewState::doFrameworkFullInval()
    202 {
    203     m_doFrameworkFullInval = true;
    204 }
    205 
    206 double GLWebViewState::setupDrawing(const IntRect& invScreenRect,
    207                                     const SkRect& visibleContentRect,
    208                                     const IntRect& screenRect, int titleBarHeight,
    209                                     const IntRect& screenClip, float scale)
    210 {
    211     TilesManager* tilesManager = TilesManager::instance();
    212 
    213     // Make sure GL resources are created on the UI thread.
    214     // They are created either for the first time, or after EGL context
    215     // recreation caused by onTrimMemory in the framework.
    216     ShaderProgram* shader = tilesManager->shader();
    217     if (shader->needsInit()) {
    218         ALOGD("Reinit shader");
    219         shader->initGLResources();
    220     }
    221     TransferQueue* transferQueue = tilesManager->transferQueue();
    222     if (transferQueue->needsInit()) {
    223         ALOGD("Reinit transferQueue");
    224         transferQueue->initGLResources(TilesManager::tileWidth(),
    225                                        TilesManager::tileHeight());
    226     }
    227     shader->setupDrawing(invScreenRect, visibleContentRect, screenRect,
    228                          titleBarHeight, screenClip, scale);
    229 
    230     double currentTime = WTF::currentTime();
    231 
    232     setVisibleContentRect(visibleContentRect, scale);
    233 
    234     return currentTime;
    235 }
    236 
    237 bool GLWebViewState::setLayersRenderingMode(TexturesResult& nbTexturesNeeded)
    238 {
    239     bool invalBase = false;
    240 
    241     if (!nbTexturesNeeded.full)
    242         TilesManager::instance()->setCurrentLayerTextureCount(0);
    243     else
    244         TilesManager::instance()->setCurrentLayerTextureCount((2 * nbTexturesNeeded.full) + 1);
    245 
    246     int maxTextures = TilesManager::instance()->currentLayerTextureCount();
    247     LayersRenderingMode layersRenderingMode = m_layersRenderingMode;
    248 
    249     if (m_layersRenderingMode == kSingleSurfaceRendering) {
    250         // only switch out of SingleSurface mode, if we have 2x needed textures
    251         // to avoid changing too often
    252         maxTextures /= 2;
    253     }
    254 
    255     m_layersRenderingMode = kSingleSurfaceRendering;
    256     if (nbTexturesNeeded.fixed < maxTextures)
    257         m_layersRenderingMode = kFixedLayers;
    258     if (nbTexturesNeeded.scrollable < maxTextures)
    259         m_layersRenderingMode = kScrollableAndFixedLayers;
    260     if (nbTexturesNeeded.clipped < maxTextures)
    261         m_layersRenderingMode = kClippedTextures;
    262     if (nbTexturesNeeded.full < maxTextures)
    263         m_layersRenderingMode = kAllTextures;
    264 
    265     if (!maxTextures && !nbTexturesNeeded.full)
    266         m_layersRenderingMode = kAllTextures;
    267 
    268     if (m_layersRenderingMode < layersRenderingMode
    269         && m_layersRenderingMode != kAllTextures)
    270         invalBase = true;
    271 
    272     if (m_layersRenderingMode > layersRenderingMode
    273         && m_layersRenderingMode != kClippedTextures)
    274         invalBase = true;
    275 
    276 #ifdef DEBUG
    277     if (m_layersRenderingMode != layersRenderingMode) {
    278         char* mode[] = { "kAllTextures", "kClippedTextures",
    279             "kScrollableAndFixedLayers", "kFixedLayers", "kSingleSurfaceRendering" };
    280         ALOGD("Change from mode %s to %s -- We need textures: fixed: %d,"
    281               " scrollable: %d, clipped: %d, full: %d, max textures: %d",
    282               static_cast<char*>(mode[layersRenderingMode]),
    283               static_cast<char*>(mode[m_layersRenderingMode]),
    284               nbTexturesNeeded.fixed,
    285               nbTexturesNeeded.scrollable,
    286               nbTexturesNeeded.clipped,
    287               nbTexturesNeeded.full, maxTextures);
    288     }
    289 #endif
    290 
    291     // For now, anything below kClippedTextures is equivalent
    292     // to kSingleSurfaceRendering
    293     // TODO: implement the other rendering modes
    294     if (m_layersRenderingMode > kClippedTextures)
    295         m_layersRenderingMode = kSingleSurfaceRendering;
    296 
    297     // update the base surface if needed
    298     // TODO: inval base layergroup when going into single surface mode
    299     return (m_layersRenderingMode != layersRenderingMode && invalBase);
    300 }
    301 
    302 // -invScreenRect is the webView's rect with inverted Y screen coordinate.
    303 // -visibleContentRect is the visible area in content coordinate.
    304 // They are both based on  webView's rect and calculated in Java side.
    305 //
    306 // -screenClip is in screen coordinate, so we need to invert the Y axis before
    307 // passing into GL functions. Clip can be smaller than the webView's rect.
    308 //
    309 // TODO: Try to decrease the number of parameters as some info is redundant.
    310 int GLWebViewState::drawGL(IntRect& invScreenRect, SkRect& visibleContentRect,
    311                            IntRect* invalRect, IntRect& screenRect, int titleBarHeight,
    312                            IntRect& screenClip, float scale,
    313                            bool* collectionsSwappedPtr, bool* newCollectionHasAnimPtr,
    314                            bool shouldDraw)
    315 {
    316     TilesManager* tilesManager = TilesManager::instance();
    317     if (shouldDraw)
    318         tilesManager->getProfiler()->nextFrame(visibleContentRect.fLeft,
    319                                                visibleContentRect.fTop,
    320                                                visibleContentRect.fRight,
    321                                                visibleContentRect.fBottom,
    322                                                scale);
    323     tilesManager->incDrawGLCount();
    324 
    325     ALOGV("drawGL, invScreenRect(%d, %d, %d, %d), visibleContentRect(%.2f, %.2f, %.2f, %.2f)",
    326           invScreenRect.x(), invScreenRect.y(), invScreenRect.width(), invScreenRect.height(),
    327           visibleContentRect.fLeft, visibleContentRect.fTop,
    328           visibleContentRect.fRight, visibleContentRect.fBottom);
    329 
    330     ALOGV("drawGL, invalRect(%d, %d, %d, %d), screenRect(%d, %d, %d, %d)"
    331           "screenClip (%d, %d, %d, %d), scale %f titleBarHeight %d",
    332           invalRect->x(), invalRect->y(), invalRect->width(), invalRect->height(),
    333           screenRect.x(), screenRect.y(), screenRect.width(), screenRect.height(),
    334           screenClip.x(), screenClip.y(), screenClip.width(), screenClip.height(), scale, titleBarHeight);
    335 
    336     m_inUnclippedDraw = shouldDraw && (screenRect == screenClip);
    337 
    338     resetLayersDirtyArea();
    339 
    340     if (scale < MIN_SCALE_WARNING || scale > MAX_SCALE_WARNING)
    341         ALOGW("WARNING, scale seems corrupted before update: %e", scale);
    342 
    343     tilesManager->updateTilesIfContextVerified();
    344 
    345     // gather the textures we can use, make sure this happens before any
    346     // texture preparation work.
    347     tilesManager->gatherTextures();
    348 
    349     // Upload any pending ImageTexture
    350     // Return true if we still have some images to upload.
    351     // TODO: upload as many textures as possible within a certain time limit
    352     int returnFlags = 0;
    353     if (ImagesManager::instance()->prepareTextures(this))
    354         returnFlags |= DrawGlInfo::kStatusDraw;
    355 
    356     if (scale < MIN_SCALE_WARNING || scale > MAX_SCALE_WARNING)
    357         ALOGW("WARNING, scale seems corrupted after update: %e", scale);
    358 
    359     double currentTime = setupDrawing(invScreenRect, visibleContentRect, screenRect,
    360                                       titleBarHeight, screenClip, scale);
    361 
    362     TexturesResult nbTexturesNeeded;
    363     bool scrolling = isScrolling();
    364     bool singleSurfaceMode = m_layersRenderingMode == kSingleSurfaceRendering;
    365     m_glExtras.setVisibleContentRect(visibleContentRect);
    366 
    367     returnFlags |= m_surfaceCollectionManager.drawGL(currentTime, invScreenRect,
    368                                                      visibleContentRect,
    369                                                      scale, scrolling,
    370                                                      singleSurfaceMode,
    371                                                      collectionsSwappedPtr,
    372                                                      newCollectionHasAnimPtr,
    373                                                      &nbTexturesNeeded, shouldDraw);
    374 
    375     int nbTexturesForImages = ImagesManager::instance()->nbTextures();
    376     ALOGV("*** We have %d textures for images, %d full, %d clipped, total %d / %d",
    377           nbTexturesForImages, nbTexturesNeeded.full, nbTexturesNeeded.clipped,
    378           nbTexturesNeeded.full + nbTexturesForImages,
    379           nbTexturesNeeded.clipped + nbTexturesForImages);
    380     nbTexturesNeeded.full += nbTexturesForImages;
    381     nbTexturesNeeded.clipped += nbTexturesForImages;
    382 
    383     if (setLayersRenderingMode(nbTexturesNeeded)) {
    384         TilesManager::instance()->dirtyAllTiles();
    385         returnFlags |= DrawGlInfo::kStatusDraw | DrawGlInfo::kStatusInvoke;
    386     }
    387 
    388     glBindBuffer(GL_ARRAY_BUFFER, 0);
    389 
    390     if (returnFlags & DrawGlInfo::kStatusDraw) {
    391         // returnFlags & kStatusDraw && empty inval region means we've inval'd everything,
    392         // but don't have new content. Keep redrawing full view (0,0,0,0)
    393         // until tile generation catches up and we swap pages.
    394         bool fullScreenInval = m_frameworkLayersInval.isEmpty() || m_doFrameworkFullInval;
    395 
    396         if (!fullScreenInval) {
    397             m_frameworkLayersInval.inflate(1);
    398 
    399             invalRect->setX(m_frameworkLayersInval.x());
    400             invalRect->setY(m_frameworkLayersInval.y());
    401             invalRect->setWidth(m_frameworkLayersInval.width());
    402             invalRect->setHeight(m_frameworkLayersInval.height());
    403 
    404             ALOGV("invalRect(%d, %d, %d, %d)", invalRect->x(),
    405                   invalRect->y(), invalRect->width(), invalRect->height());
    406 
    407             if (!invalRect->intersects(invScreenRect)) {
    408                 // invalidate is occurring offscreen, do full inval to guarantee redraw
    409                 fullScreenInval = true;
    410             }
    411         }
    412 
    413         if (fullScreenInval) {
    414             invalRect->setX(0);
    415             invalRect->setY(0);
    416             invalRect->setWidth(0);
    417             invalRect->setHeight(0);
    418         }
    419     }
    420 
    421     if (shouldDraw)
    422         showFrameInfo(invScreenRect, *collectionsSwappedPtr);
    423 
    424     return returnFlags;
    425 }
    426 
    427 void GLWebViewState::showFrameInfo(const IntRect& rect, bool collectionsSwapped)
    428 {
    429     bool showVisualIndicator = TilesManager::instance()->getShowVisualIndicator();
    430 
    431     bool drawOrDumpFrameInfo = showVisualIndicator;
    432 #ifdef MEASURES_PERF
    433     drawOrDumpFrameInfo |= m_measurePerfs;
    434 #endif
    435     if (!drawOrDumpFrameInfo)
    436         return;
    437 
    438     double currentDrawTime = WTF::currentTime();
    439     double delta = currentDrawTime - m_prevDrawTime;
    440     m_prevDrawTime = currentDrawTime;
    441 
    442 #ifdef MEASURES_PERF
    443     if (m_measurePerfs) {
    444         m_delayTimes[m_timeCounter++] = delta;
    445         if (m_timeCounter >= MAX_MEASURES_PERF)
    446             dumpMeasures();
    447     }
    448 #endif
    449 
    450     IntRect frameInfoRect = rect;
    451     frameInfoRect.setHeight(FPS_INDICATOR_HEIGHT);
    452     double ratio = (1.0 / delta) / MAX_FPS_VALUE;
    453 
    454     clearRectWithColor(frameInfoRect, 1, 1, 1, 1);
    455     frameInfoRect.setWidth(frameInfoRect.width() * ratio);
    456     clearRectWithColor(frameInfoRect, 1, 0, 0, 1);
    457 
    458     // Draw the collection swap counter as a circling progress bar.
    459     // This will basically show how fast we are updating the collection.
    460     static int swappedCounter = 0;
    461     if (collectionsSwapped)
    462         swappedCounter = (swappedCounter + 1) % COLLECTION_SWAPPED_COUNTER_MODULE;
    463 
    464     frameInfoRect = rect;
    465     frameInfoRect.setHeight(FPS_INDICATOR_HEIGHT);
    466     frameInfoRect.move(0, FPS_INDICATOR_HEIGHT);
    467 
    468     clearRectWithColor(frameInfoRect, 1, 1, 1, 1);
    469     ratio = (swappedCounter + 1.0) / COLLECTION_SWAPPED_COUNTER_MODULE;
    470 
    471     frameInfoRect.setWidth(frameInfoRect.width() * ratio);
    472     clearRectWithColor(frameInfoRect, 0, 1, 0, 1);
    473 }
    474 
    475 void GLWebViewState::clearRectWithColor(const IntRect& rect, float r, float g,
    476                                       float b, float a)
    477 {
    478     glScissor(rect.x(), rect.y(), rect.width(), rect.height());
    479     glClearColor(r, g, b, a);
    480     glClear(GL_COLOR_BUFFER_BIT);
    481 }
    482 
    483 } // namespace WebCore
    484 
    485 #endif // USE(ACCELERATED_COMPOSITING)
    486