Refactor HardwareLayer
Defer all the things!
Groundwork to allow hardware layers to work in a renderthread world
Change-Id: Ib3aa47525f393083621254a743dbaa6352f933bd
diff --git a/libs/hwui/Android.mk b/libs/hwui/Android.mk
index 8c388d9..495ad19 100644
--- a/libs/hwui/Android.mk
+++ b/libs/hwui/Android.mk
@@ -17,6 +17,7 @@
Caches.cpp \
DisplayList.cpp \
DeferredDisplayList.cpp \
+ DeferredLayerUpdater.cpp \
DisplayListLogBuffer.cpp \
DisplayListRenderer.cpp \
Dither.cpp \
@@ -70,7 +71,7 @@
LOCAL_CFLAGS += -DUSE_OPENGL_RENDERER -DEGL_EGLEXT_PROTOTYPES -DGL_GLEXT_PROTOTYPES
LOCAL_CFLAGS += -Wno-unused-parameter
LOCAL_MODULE_CLASS := SHARED_LIBRARIES
- LOCAL_SHARED_LIBRARIES := liblog libcutils libutils libEGL libGLESv2 libskia libui
+ LOCAL_SHARED_LIBRARIES := liblog libcutils libutils libEGL libGLESv2 libskia libui libgui
LOCAL_MODULE := libhwui
LOCAL_MODULE_TAGS := optional
diff --git a/libs/hwui/DeferredLayerUpdater.cpp b/libs/hwui/DeferredLayerUpdater.cpp
new file mode 100644
index 0000000..ed05d04
--- /dev/null
+++ b/libs/hwui/DeferredLayerUpdater.cpp
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "DeferredLayerUpdater.h"
+
+#include "OpenGLRenderer.h"
+
+#include "LayerRenderer.h"
+
+namespace android {
+namespace uirenderer {
+
+DeferredLayerUpdater::DeferredLayerUpdater(Layer* layer, OpenGLRenderer* renderer)
+ : mDisplayList(0)
+ , mSurfaceTexture(0)
+ , mTransform(0)
+ , mNeedsGLContextAttach(false)
+ , mUpdateTexImage(false)
+ , mLayer(layer)
+ , mRenderer(renderer)
+ , mCaches(Caches::getInstance()) {
+ mCaches.resourceCache.incrementRefcount(mLayer);
+ mWidth = mLayer->layer.getWidth();
+ mHeight = mLayer->layer.getHeight();
+ mBlend = mLayer->isBlend();
+ mColorFilter = mLayer->getColorFilter();
+ mAlpha = mLayer->getAlpha();
+ mMode = mLayer->getMode();
+ mDirtyRect.setEmpty();
+}
+
+DeferredLayerUpdater::~DeferredLayerUpdater() {
+ setColorFilter(NULL);
+ if (mLayer) {
+ mCaches.resourceCache.decrementRefcount(mLayer);
+ }
+ delete mRenderer;
+}
+
+void DeferredLayerUpdater::setColorFilter(SkColorFilter* colorFilter) {
+ SkRefCnt_SafeAssign(mColorFilter, colorFilter);
+}
+
+void DeferredLayerUpdater::setDisplayList(DisplayList* displayList,
+ int left, int top, int right, int bottom) {
+ mDisplayList = displayList;
+ if (mDirtyRect.isEmpty()) {
+ mDirtyRect.set(left, top, right, bottom);
+ } else {
+ mDirtyRect.unionWith(Rect(left, top, right, bottom));
+ }
+}
+
+bool DeferredLayerUpdater::apply() {
+ bool success = true;
+ // These properties are applied the same to both layer types
+ mLayer->setColorFilter(mColorFilter);
+ mLayer->setAlpha(mAlpha, mMode);
+
+ if (mDisplayList) {
+ if (mWidth != mLayer->layer.getWidth() || mHeight != mLayer->layer.getHeight()) {
+ success = LayerRenderer::resizeLayer(mLayer, mWidth, mHeight);
+ }
+ mLayer->setBlend(mBlend);
+ mLayer->updateDeferred(mRenderer, mDisplayList,
+ mDirtyRect.left, mDirtyRect.top, mDirtyRect.right, mDirtyRect.bottom);
+ mDirtyRect.setEmpty();
+ mDisplayList = 0;
+ } else if (mSurfaceTexture.get()) {
+ if (mNeedsGLContextAttach) {
+ mNeedsGLContextAttach = false;
+ mSurfaceTexture->attachToContext(mLayer->getTexture());
+ }
+ if (mUpdateTexImage) {
+ mUpdateTexImage = false;
+ doUpdateTexImage();
+ }
+ if (mTransform) {
+ mLayer->getTransform().load(*mTransform);
+ setTransform(0);
+ }
+ }
+ return success;
+}
+
+void DeferredLayerUpdater::doUpdateTexImage() {
+ if (mSurfaceTexture->updateTexImage() == NO_ERROR) {
+ float transform[16];
+
+ int64_t frameNumber = mSurfaceTexture->getFrameNumber();
+ // If the GLConsumer queue is in synchronous mode, need to discard all
+ // but latest frame, using the frame number to tell when we no longer
+ // have newer frames to target. Since we can't tell which mode it is in,
+ // do this unconditionally.
+ int dropCounter = 0;
+ while (mSurfaceTexture->updateTexImage() == NO_ERROR) {
+ int64_t newFrameNumber = mSurfaceTexture->getFrameNumber();
+ if (newFrameNumber == frameNumber) break;
+ frameNumber = newFrameNumber;
+ dropCounter++;
+ }
+ #if DEBUG_RENDERER
+ if (dropCounter > 0) {
+ RENDERER_LOGD("Dropped %d frames on texture layer update", dropCounter);
+ }
+ #endif
+ mSurfaceTexture->getTransformMatrix(transform);
+ GLenum renderTarget = mSurfaceTexture->getCurrentTextureTarget();
+
+ LayerRenderer::updateTextureLayer(mLayer, mWidth, mHeight, !mBlend,
+ renderTarget, transform);
+ }
+}
+
+void DeferredLayerUpdater::applyDeferred(DeferredLayerUpdater* deferredApply) {
+ // Default assignment operator doesn't quite work, and fails due to mCaches anyway
+ deferredApply->mWidth = mWidth;
+ deferredApply->mHeight = mHeight;
+ deferredApply->mBlend = mBlend;
+ deferredApply->mAlpha = mAlpha;
+ deferredApply->mMode = mMode;
+ deferredApply->mDirtyRect.set(mDirtyRect);
+ deferredApply->mDisplayList = mDisplayList;
+ deferredApply->mSurfaceTexture = mSurfaceTexture;
+ deferredApply->mNeedsGLContextAttach = mNeedsGLContextAttach;
+ deferredApply->mUpdateTexImage = mUpdateTexImage;
+ deferredApply->setColorFilter(mColorFilter);
+ deferredApply->setTransform(mTransform);
+
+ mDisplayList = 0;
+ mDirtyRect.setEmpty();
+ mTransform = 0;
+ mNeedsGLContextAttach = false;
+ mUpdateTexImage = false;
+}
+
+} /* namespace uirenderer */
+} /* namespace android */
diff --git a/libs/hwui/DeferredLayerUpdater.h b/libs/hwui/DeferredLayerUpdater.h
new file mode 100644
index 0000000..0350eef
--- /dev/null
+++ b/libs/hwui/DeferredLayerUpdater.h
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef DEFERREDLAYERUPDATE_H_
+#define DEFERREDLAYERUPDATE_H_
+
+#include <cutils/compiler.h>
+#include <gui/GLConsumer.h>
+#include <SkColorFilter.h>
+#include <SkMatrix.h>
+#include <utils/StrongPointer.h>
+
+#include "DisplayList.h"
+#include "Layer.h"
+#include "OpenGLRenderer.h"
+#include "Rect.h"
+
+namespace android {
+namespace uirenderer {
+
+// Container to hold the properties a layer should be set to at the start
+// of a render pass
+class DeferredLayerUpdater {
+public:
+ ANDROID_API DeferredLayerUpdater(Layer* layer, OpenGLRenderer* renderer = 0);
+ ANDROID_API ~DeferredLayerUpdater();
+
+ ANDROID_API bool setSize(uint32_t width, uint32_t height) {
+ if (mWidth != width || mHeight != height) {
+ mWidth = width;
+ mHeight = height;
+ return true;
+ }
+ return false;
+ }
+
+ ANDROID_API bool setBlend(bool blend) {
+ if (blend != mBlend) {
+ mBlend = blend;
+ return true;
+ }
+ return false;
+ }
+
+ ANDROID_API void setSurfaceTexture(const sp<GLConsumer>& texture, bool needsAttach) {
+ if (texture.get() != mSurfaceTexture.get()) {
+ mNeedsGLContextAttach = needsAttach;
+ mSurfaceTexture = texture;
+ }
+ }
+
+ ANDROID_API void updateTexImage() {
+ mUpdateTexImage = true;
+ }
+
+ ANDROID_API void setTransform(const SkMatrix* matrix) {
+ delete mTransform;
+ mTransform = matrix ? new SkMatrix(*matrix) : 0;
+ }
+
+ ANDROID_API void setDisplayList(DisplayList* displayList,
+ int left, int top, int right, int bottom);
+
+ ANDROID_API void setPaint(const SkPaint* paint) {
+ OpenGLRenderer::getAlphaAndModeDirect(paint, &mAlpha, &mMode);
+ }
+
+ ANDROID_API void setColorFilter(SkColorFilter* colorFilter);
+
+ ANDROID_API bool apply();
+ ANDROID_API void applyDeferred(DeferredLayerUpdater* deferredApply);
+
+ ANDROID_API Layer* backingLayer() {
+ return mLayer;
+ }
+
+ ANDROID_API Layer* detachBackingLayer() {
+ Layer* layer = mLayer;
+ mLayer = 0;
+ return layer;
+ }
+
+private:
+ // Generic properties
+ uint32_t mWidth;
+ uint32_t mHeight;
+ bool mBlend;
+ SkColorFilter* mColorFilter;
+ int mAlpha;
+ SkXfermode::Mode mMode;
+
+ // Layer type specific properties
+ // displayList and surfaceTexture are mutually exclusive, only 1 may be set
+ // dirtyRect is only valid if displayList is set
+ DisplayList* mDisplayList;
+ Rect mDirtyRect;
+ sp<GLConsumer> mSurfaceTexture;
+ SkMatrix* mTransform;
+ bool mNeedsGLContextAttach;
+ bool mUpdateTexImage;
+
+ Layer* mLayer;
+ OpenGLRenderer* mRenderer;
+ Caches& mCaches;
+
+ void doUpdateTexImage();
+};
+
+} /* namespace uirenderer */
+} /* namespace android */
+
+#endif /* DEFERREDLAYERUPDATE_H_ */
diff --git a/libs/hwui/LayerRenderer.cpp b/libs/hwui/LayerRenderer.cpp
index 0b38c4d..ea8eb31 100644
--- a/libs/hwui/LayerRenderer.cpp
+++ b/libs/hwui/LayerRenderer.cpp
@@ -184,7 +184,7 @@
// Layers management
///////////////////////////////////////////////////////////////////////////////
-Layer* LayerRenderer::createLayer(uint32_t width, uint32_t height, bool isOpaque) {
+Layer* LayerRenderer::createRenderLayer(uint32_t width, uint32_t height) {
LAYER_RENDERER_LOGD("Requesting new render layer %dx%d", width, height);
Caches& caches = Caches::getInstance();
@@ -221,7 +221,6 @@
layer->texCoords.set(0.0f, height / float(layer->getHeight()),
width / float(layer->getWidth()), 0.0f);
layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
- layer->setBlend(!isOpaque);
layer->setColorFilter(NULL);
layer->setDirty(true);
layer->region.clear();
@@ -270,13 +269,12 @@
return true;
}
-Layer* LayerRenderer::createTextureLayer(bool isOpaque) {
+Layer* LayerRenderer::createTextureLayer() {
LAYER_RENDERER_LOGD("Creating new texture layer");
Layer* layer = new Layer(0, 0);
layer->setCacheable(false);
layer->setTextureLayer(true);
- layer->setBlend(!isOpaque);
layer->setEmpty(true);
layer->setFbo(0);
layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
diff --git a/libs/hwui/LayerRenderer.h b/libs/hwui/LayerRenderer.h
index f24c8d4..84acd44 100644
--- a/libs/hwui/LayerRenderer.h
+++ b/libs/hwui/LayerRenderer.h
@@ -52,8 +52,8 @@
virtual status_t clear(float left, float top, float right, float bottom, bool opaque);
virtual void finish();
- ANDROID_API static Layer* createTextureLayer(bool isOpaque);
- ANDROID_API static Layer* createLayer(uint32_t width, uint32_t height, bool isOpaque = false);
+ ANDROID_API static Layer* createTextureLayer();
+ ANDROID_API static Layer* createRenderLayer(uint32_t width, uint32_t height);
ANDROID_API static bool resizeLayer(Layer* layer, uint32_t width, uint32_t height);
ANDROID_API static void updateTextureLayer(Layer* layer, uint32_t width, uint32_t height,
bool isOpaque, GLenum renderTarget, float* transform);