DeferredLayerUpdater.cpp revision e4267ea4f20740c37c01bfb6aefcf61fddc4566a 
1/*
2 * Copyright (C) 2014 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#include "DeferredLayerUpdater.h"
17
18#include "OpenGLRenderer.h"
19
20#include "LayerRenderer.h"
21
22namespace android {
23namespace uirenderer {
24
25static void defaultLayerDestroyer(Layer* layer) {
26    Caches::getInstance().resourceCache.decrementRefcount(layer);
27}
28
29DeferredLayerUpdater::DeferredLayerUpdater(Layer* layer, LayerDestroyer destroyer)
30        : mDisplayList(0)
31        , mSurfaceTexture(0)
32        , mTransform(0)
33        , mNeedsGLContextAttach(false)
34        , mUpdateTexImage(false)
35        , mLayer(layer)
36        , mCaches(Caches::getInstance())
37        , mDestroyer(destroyer) {
38    mWidth = mLayer->layer.getWidth();
39    mHeight = mLayer->layer.getHeight();
40    mBlend = mLayer->isBlend();
41    mColorFilter = SkSafeRef(mLayer->getColorFilter());
42    mAlpha = mLayer->getAlpha();
43    mMode = mLayer->getMode();
44    mDirtyRect.setEmpty();
45
46    if (!mDestroyer) {
47        mDestroyer = defaultLayerDestroyer;
48    }
49}
50
51DeferredLayerUpdater::~DeferredLayerUpdater() {
52    SkSafeUnref(mColorFilter);
53    setTransform(0);
54    mDestroyer(mLayer);
55}
56
57void DeferredLayerUpdater::setPaint(const SkPaint* paint) {
58    OpenGLRenderer::getAlphaAndModeDirect(paint, &mAlpha, &mMode);
59    SkColorFilter* colorFilter = (paint) ? paint->getColorFilter() : NULL;
60    SkRefCnt_SafeAssign(mColorFilter, colorFilter);
61}
62
63void DeferredLayerUpdater::setDisplayList(RenderNode* displayList,
64        int left, int top, int right, int bottom) {
65    mDisplayList = displayList;
66    if (mDirtyRect.isEmpty()) {
67        mDirtyRect.set(left, top, right, bottom);
68    } else {
69        mDirtyRect.unionWith(Rect(left, top, right, bottom));
70    }
71}
72
73bool DeferredLayerUpdater::apply(TreeInfo& info) {
74    bool success = true;
75    // These properties are applied the same to both layer types
76    mLayer->setColorFilter(mColorFilter);
77    mLayer->setAlpha(mAlpha, mMode);
78
79    if (mDisplayList.get()) {
80        if (mWidth != mLayer->layer.getWidth() || mHeight != mLayer->layer.getHeight()) {
81            success = LayerRenderer::resizeLayer(mLayer, mWidth, mHeight);
82        }
83        mLayer->setBlend(mBlend);
84        // TODO: Use DamageAccumulator to get the damage area for the layer's
85        // subtree to only update that part of the layer. Do this as part of
86        // reworking layers to be a RenderProperty instead of a View-managed object
87        mDirtyRect.set(0, 0, mWidth, mHeight);
88        mDisplayList->prepareTree(info);
89        mLayer->updateDeferred(mDisplayList.get(),
90                mDirtyRect.left, mDirtyRect.top, mDirtyRect.right, mDirtyRect.bottom);
91        mDirtyRect.setEmpty();
92        mDisplayList = 0;
93    } else if (mSurfaceTexture.get()) {
94        if (mNeedsGLContextAttach) {
95            mNeedsGLContextAttach = false;
96            mSurfaceTexture->attachToContext(mLayer->getTexture());
97        }
98        if (mUpdateTexImage) {
99            mUpdateTexImage = false;
100            doUpdateTexImage();
101        }
102        if (mTransform) {
103            mLayer->getTransform().load(*mTransform);
104            setTransform(0);
105        }
106    }
107    return success;
108}
109
110void DeferredLayerUpdater::doUpdateTexImage() {
111    if (mSurfaceTexture->updateTexImage() == NO_ERROR) {
112        float transform[16];
113
114        int64_t frameNumber = mSurfaceTexture->getFrameNumber();
115        // If the GLConsumer queue is in synchronous mode, need to discard all
116        // but latest frame, using the frame number to tell when we no longer
117        // have newer frames to target. Since we can't tell which mode it is in,
118        // do this unconditionally.
119        int dropCounter = 0;
120        while (mSurfaceTexture->updateTexImage() == NO_ERROR) {
121            int64_t newFrameNumber = mSurfaceTexture->getFrameNumber();
122            if (newFrameNumber == frameNumber) break;
123            frameNumber = newFrameNumber;
124            dropCounter++;
125        }
126
127        bool forceFilter = false;
128        sp<GraphicBuffer> buffer = mSurfaceTexture->getCurrentBuffer();
129        if (buffer != NULL) {
130            // force filtration if buffer size != layer size
131            forceFilter = mWidth != buffer->getWidth()
132                    || mHeight != buffer->getHeight();
133        }
134
135        #if DEBUG_RENDERER
136        if (dropCounter > 0) {
137            RENDERER_LOGD("Dropped %d frames on texture layer update", dropCounter);
138        }
139        #endif
140        mSurfaceTexture->getTransformMatrix(transform);
141        GLenum renderTarget = mSurfaceTexture->getCurrentTextureTarget();
142
143        LayerRenderer::updateTextureLayer(mLayer, mWidth, mHeight,
144                !mBlend, forceFilter, renderTarget, transform);
145    }
146}
147
148} /* namespace uirenderer */
149} /* namespace android */
150