DeferredLayerUpdater.cpp revision e889298cd6ae1fc0d76bc00d7d12586db03eb261 
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
25DeferredLayerUpdater::DeferredLayerUpdater(Layer* layer, OpenGLRenderer* renderer)
26        : mDisplayList(0)
27        , mSurfaceTexture(0)
28        , mTransform(0)
29        , mNeedsGLContextAttach(false)
30        , mUpdateTexImage(false)
31        , mLayer(layer)
32        , mRenderer(renderer)
33        , mCaches(Caches::getInstance()) {
34    mCaches.resourceCache.incrementRefcount(mLayer);
35    SkRefCnt_SafeAssign(mColorFilter, mLayer->getColorFilter());
36    mWidth = mLayer->layer.getWidth();
37    mHeight = mLayer->layer.getHeight();
38    mBlend = mLayer->isBlend();
39    mAlpha = mLayer->getAlpha();
40    mMode = mLayer->getMode();
41    mDirtyRect.setEmpty();
42}
43
44DeferredLayerUpdater::~DeferredLayerUpdater() {
45    SkSafeUnref(mColorFilter);
46    if (mLayer) {
47        mCaches.resourceCache.decrementRefcount(mLayer);
48    }
49    delete mRenderer;
50}
51
52void DeferredLayerUpdater::setPaint(const SkPaint* paint) {
53    OpenGLRenderer::getAlphaAndModeDirect(paint, &mAlpha, &mMode);
54    SkColorFilter* colorFilter = (paint) ? paint->getColorFilter() : NULL;
55    SkRefCnt_SafeAssign(mColorFilter, colorFilter);
56}
57
58void DeferredLayerUpdater::setDisplayList(DisplayList* displayList,
59        int left, int top, int right, int bottom) {
60    mDisplayList = displayList;
61    if (mDirtyRect.isEmpty()) {
62        mDirtyRect.set(left, top, right, bottom);
63    } else {
64        mDirtyRect.unionWith(Rect(left, top, right, bottom));
65    }
66}
67
68bool DeferredLayerUpdater::apply() {
69    bool success = true;
70    // These properties are applied the same to both layer types
71    mLayer->setColorFilter(mColorFilter);
72    mLayer->setAlpha(mAlpha, mMode);
73
74    if (mDisplayList) {
75        if (mWidth != mLayer->layer.getWidth() || mHeight != mLayer->layer.getHeight()) {
76            success = LayerRenderer::resizeLayer(mLayer, mWidth, mHeight);
77        }
78        mLayer->setBlend(mBlend);
79        mLayer->updateDeferred(mRenderer, mDisplayList,
80                mDirtyRect.left, mDirtyRect.top, mDirtyRect.right, mDirtyRect.bottom);
81        mDirtyRect.setEmpty();
82        mDisplayList = 0;
83    } else if (mSurfaceTexture.get()) {
84        if (mNeedsGLContextAttach) {
85            mNeedsGLContextAttach = false;
86            mSurfaceTexture->attachToContext(mLayer->getTexture());
87        }
88        if (mUpdateTexImage) {
89            mUpdateTexImage = false;
90            doUpdateTexImage();
91        }
92        if (mTransform) {
93            mLayer->getTransform().load(*mTransform);
94            setTransform(0);
95        }
96    }
97    return success;
98}
99
100void DeferredLayerUpdater::doUpdateTexImage() {
101    if (mSurfaceTexture->updateTexImage() == NO_ERROR) {
102        float transform[16];
103
104        int64_t frameNumber = mSurfaceTexture->getFrameNumber();
105        // If the GLConsumer queue is in synchronous mode, need to discard all
106        // but latest frame, using the frame number to tell when we no longer
107        // have newer frames to target. Since we can't tell which mode it is in,
108        // do this unconditionally.
109        int dropCounter = 0;
110        while (mSurfaceTexture->updateTexImage() == NO_ERROR) {
111            int64_t newFrameNumber = mSurfaceTexture->getFrameNumber();
112            if (newFrameNumber == frameNumber) break;
113            frameNumber = newFrameNumber;
114            dropCounter++;
115        }
116        #if DEBUG_RENDERER
117        if (dropCounter > 0) {
118            RENDERER_LOGD("Dropped %d frames on texture layer update", dropCounter);
119        }
120        #endif
121        mSurfaceTexture->getTransformMatrix(transform);
122        GLenum renderTarget = mSurfaceTexture->getCurrentTextureTarget();
123
124        LayerRenderer::updateTextureLayer(mLayer, mWidth, mHeight, !mBlend,
125                renderTarget, transform);
126    }
127}
128
129void DeferredLayerUpdater::applyDeferred(DeferredLayerUpdater* deferredApply) {
130    // Default assignment operator doesn't quite work, and fails due to mCaches anyway
131    deferredApply->mWidth = mWidth;
132    deferredApply->mHeight = mHeight;
133    deferredApply->mBlend = mBlend;
134    deferredApply->mAlpha = mAlpha;
135    deferredApply->mMode = mMode;
136    deferredApply->mDirtyRect.set(mDirtyRect);
137    deferredApply->mDisplayList = mDisplayList;
138    deferredApply->mSurfaceTexture = mSurfaceTexture;
139    deferredApply->mNeedsGLContextAttach = mNeedsGLContextAttach;
140    deferredApply->mUpdateTexImage = mUpdateTexImage;
141    deferredApply->setTransform(mTransform);
142
143    SkRefCnt_SafeAssign(deferredApply->mColorFilter, mColorFilter);
144
145    mDisplayList = 0;
146    mDirtyRect.setEmpty();
147    mTransform = 0;
148    mNeedsGLContextAttach = false;
149    mUpdateTexImage = false;
150}
151
152} /* namespace uirenderer */
153} /* namespace android */
154