Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge change 6862 into donut

Browse Source 
* changes:
  fix [1967226] Donut orientation animation (dimming and blur) is slower than Cupcake
This commit is contained in:
Android (Google) Code Review
2009-07-10 17:10:57 -07:00
parent 086bd7fed1 f31d407ab8
commit e4bd6e7eb9
6 changed files with 17 additions and 506 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
libs/surfaceflinger/Android.mk
View File

@@ -15,7 +15,6 @@ LOCAL_SRC_FILES:= \
LayerBitmap.cpp \
LayerDim.cpp \
LayerOrientationAnim.cpp \
LayerOrientationAnimRotate.cpp \
OrientationAnimation.cpp \
SurfaceFlinger.cpp \
Tokenizer.cpp \

127
libs/surfaceflinger/LayerOrientationAnim.cpp
View File

@@ -46,10 +46,7 @@ const char* const LayerOrientationAnim::typeID = "LayerOrientationAnim";
// Animation...
const float DURATION = ms2ns(200);
const float BOUNCES_PER_SECOND = 0.5f;
//const float BOUNCES_AMPLITUDE = 1.0f/16.0f;
const float BOUNCES_AMPLITUDE = 0;
const float DIM_TARGET = 0.40f;
//#define INTERPOLATED_TIME(_t) ((_t)*(_t))
#define INTERPOLATED_TIME(_t) (_t)
// ---------------------------------------------------------------------------
@@ -64,14 +61,8 @@ LayerOrientationAnim::LayerOrientationAnim(
mTextureName(-1), mTextureNameIn(-1)
{
// blur that texture.
mStartTime = systemTime();
mFinishTime = 0;
mOrientationCompleted = false;
mFirstRedraw = false;
mLastNormalizedTime = 0;
mNeedsBlending = false;
mAlphaInLerp.set(1.0f, DIM_TARGET);
mAlphaOutLerp.set(0.5f, 1.0f);
}
LayerOrientationAnim::~LayerOrientationAnim()
@@ -117,108 +108,37 @@ void LayerOrientationAnim::validateVisibility(const Transform&)
void LayerOrientationAnim::onOrientationCompleted()
{
mFinishTime = systemTime();
mOrientationCompleted = true;
mFirstRedraw = true;
mNeedsBlending = true;
mFlinger->invalidateLayerVisibility(this);
mAnim->onAnimationFinished();
}
void LayerOrientationAnim::onDraw(const Region& clip) const
{
const nsecs_t now = systemTime();
float alphaIn, alphaOut;
float alphaIn = DIM_TARGET;
if (mOrientationCompleted) {
if (mFirstRedraw) {
mFirstRedraw = false;
// make a copy of what's on screen
copybit_image_t image;
mBitmapOut.getBitmapSurface(&image);
const DisplayHardware& hw(graphicPlane(0).displayHardware());
hw.copyBackToImage(image);
// and erase the screen for this round
glDisable(GL_BLEND);
glDisable(GL_DITHER);
glDisable(GL_SCISSOR_TEST);
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
// FIXME: code below is gross
mNeedsBlending = false;
LayerOrientationAnim* self(const_cast<LayerOrientationAnim*>(this));
mFlinger->invalidateLayerVisibility(self);
}
// make sure pick-up where we left off
const float duration = DURATION * mLastNormalizedTime;
const float normalizedTime = (float(now - mFinishTime) / duration);
if (normalizedTime <= 1.0f) {
const float interpolatedTime = INTERPOLATED_TIME(normalizedTime);
alphaIn = mAlphaInLerp.getOut();
alphaOut = mAlphaOutLerp(interpolatedTime);
} else {
mAnim->onAnimationFinished();
alphaIn = mAlphaInLerp.getOut();
alphaOut = mAlphaOutLerp.getOut();
}
} else {
const float normalizedTime = float(now - mStartTime) / DURATION;
if (normalizedTime <= 1.0f) {
mLastNormalizedTime = normalizedTime;
const float interpolatedTime = INTERPOLATED_TIME(normalizedTime);
alphaIn = mAlphaInLerp(interpolatedTime);
alphaOut = 0.0f;
} else {
mLastNormalizedTime = 1.0f;
const float to_seconds = DURATION / seconds(1);
alphaIn = mAlphaInLerp.getOut();
if (BOUNCES_AMPLITUDE > 0.0f) {
const float phi = BOUNCES_PER_SECOND *
(((normalizedTime - 1.0f) * to_seconds)*M_PI*2);
if (alphaIn > 1.0f) alphaIn = 1.0f;
else if (alphaIn < 0.0f) alphaIn = 0.0f;
alphaIn += BOUNCES_AMPLITUDE * (1.0f - cosf(phi));
}
alphaOut = 0.0f;
}
mAlphaOutLerp.setIn(alphaIn);
// clear screen
// TODO: with update on demand, we may be able
// to not erase the screen at all during the animation
if (!mOrientationCompleted) {
glDisable(GL_BLEND);
glDisable(GL_DITHER);
glDisable(GL_SCISSOR_TEST);
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
}
drawScaled(1.0f, alphaIn, alphaOut);
}
void LayerOrientationAnim::drawScaled(float scale, float alphaIn, float alphaOut) const
{
copybit_image_t dst;
const GraphicPlane& plane(graphicPlane(0));
const DisplayHardware& hw(plane.displayHardware());
hw.getDisplaySurface(&dst);
// clear screen
// TODO: with update on demand, we may be able
// to not erase the screen at all during the animation
if (!mOrientationCompleted) {
if (scale==1.0f && (alphaIn>=1.0f || alphaOut>=1.0f)) {
// we don't need to erase the screen in that case
} else {
glDisable(GL_BLEND);
glDisable(GL_DITHER);
glDisable(GL_SCISSOR_TEST);
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
}
}
copybit_image_t src;
mBitmapIn.getBitmapSurface(&src);
copybit_image_t srcOut;
mBitmapOut.getBitmapSurface(&srcOut);
const int w = dst.w*scale;
const int h = dst.h*scale;
const int w = dst.w;
const int h = dst.h;
const int xc = uint32_t(dst.w-w)/2;
const int yc = uint32_t(dst.h-h)/2;
const copybit_rect_t drect = { xc, yc, xc+w, yc+h };
@@ -237,13 +157,7 @@ void LayerOrientationAnim::drawScaled(float scale, float alphaIn, float alphaOut
copybit->set_parameter(copybit, COPYBIT_BLUR, COPYBIT_ENABLE);
copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, int(alphaIn*255));
err = copybit->stretch(copybit, &dst, &src, &drect, &srect, &it);
}
if (!err && alphaOut > 0.0f) {
region_iterator it(reg);
copybit->set_parameter(copybit, COPYBIT_BLUR, COPYBIT_DISABLE);
copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, int(alphaOut*255));
err = copybit->stretch(copybit, &dst, &srcOut, &drect, &srect, &it);
}
LOGE_IF(err != NO_ERROR, "copybit failed (%s)", strerror(err));
}
@@ -258,7 +172,6 @@ void LayerOrientationAnim::drawScaled(float scale, float alphaIn, float alphaOut
t.data = (GGLubyte*)(intptr_t(src.base) + src.offset);
Transform tr;
tr.set(scale,0,0,scale);
tr.set(xc, yc);
// FIXME: we should not access mVertices and mDrawingState like that,
@@ -285,18 +198,6 @@ void LayerOrientationAnim::drawScaled(float scale, float alphaIn, float alphaOut
self.mDrawingState.alpha = int(alphaIn*255);
drawWithOpenGL(reg, mTextureNameIn, t);
}
if (alphaOut > 0.0f) {
t.data = (GGLubyte*)(intptr_t(srcOut.base) + srcOut.offset);
if (UNLIKELY(mTextureName == -1LU)) {
mTextureName = createTexture();
GLuint w=0, h=0;
const Region dirty(Rect(t.width, t.height));
loadTexture(dirty, mTextureName, t, w, h);
}
self.mDrawingState.alpha = int(alphaOut*255);
drawWithOpenGL(reg, mTextureName, t);
}
}
}

32
libs/surfaceflinger/LayerOrientationAnim.h
View File

@@ -64,45 +64,13 @@ public:
virtual bool needsBlending() const;
virtual bool isSecure() const { return false; }
private:
void drawScaled(float scale, float alphaIn, float alphaOut) const;
class Lerp {
float in;
float outMinusIn;
public:
Lerp() : in(0), outMinusIn(0) { }
Lerp(float in, float out) : in(in), outMinusIn(out-in) { }
float getIn() const { return in; };
float getOut() const { return in + outMinusIn; }
void set(float in, float out) {
this->in = in;
this->outMinusIn = out-in;
}
void setIn(float in) {
this->in = in;
}
void setOut(float out) {
this->outMinusIn = out - this->in;
}
float operator()(float t) const {
return outMinusIn*t + in;
}
};
OrientationAnimation* mAnim;
LayerBitmap mBitmapIn;
LayerBitmap mBitmapOut;
nsecs_t mStartTime;
nsecs_t mFinishTime;
bool mOrientationCompleted;
mutable bool mFirstRedraw;
mutable float mLastNormalizedTime;
mutable GLuint mTextureName;
mutable GLuint mTextureNameIn;
mutable bool mNeedsBlending;
mutable Lerp mAlphaInLerp;
mutable Lerp mAlphaOutLerp;
};
// ---------------------------------------------------------------------------

274
libs/surfaceflinger/LayerOrientationAnimRotate.cpp
View File

@@ -1,274 +0,0 @@
/*
* Copyright (C) 2007 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.
*/
#define LOG_TAG "SurfaceFlinger"
#include <stdlib.h>
#include <stdint.h>
#include <sys/types.h>
#include <utils/Errors.h>
#include <utils/Log.h>
#include <core/SkBitmap.h>
#include <ui/EGLDisplaySurface.h>
#include "LayerBase.h"
#include "LayerOrientationAnim.h"
#include "LayerOrientationAnimRotate.h"
#include "SurfaceFlinger.h"
#include "DisplayHardware/DisplayHardware.h"
#include "OrientationAnimation.h"
namespace android {
// ---------------------------------------------------------------------------
const uint32_t LayerOrientationAnimRotate::typeInfo = LayerBase::typeInfo | 0x100;
const char* const LayerOrientationAnimRotate::typeID = "LayerOrientationAnimRotate";
// ---------------------------------------------------------------------------
const float ROTATION = M_PI * 0.5f;
const float ROTATION_FACTOR = 1.0f; // 1.0 or 2.0
const float DURATION = ms2ns(200);
const float BOUNCES_PER_SECOND = 0.8;
const float BOUNCES_AMPLITUDE = (5.0f/180.f) * M_PI;
LayerOrientationAnimRotate::LayerOrientationAnimRotate(
SurfaceFlinger* flinger, DisplayID display,
OrientationAnimation* anim,
const LayerBitmap& bitmap,
const LayerBitmap& bitmapIn)
: LayerOrientationAnimBase(flinger, display), mAnim(anim),
mBitmap(bitmap), mBitmapIn(bitmapIn),
mTextureName(-1), mTextureNameIn(-1)
{
mStartTime = systemTime();
mFinishTime = 0;
mOrientationCompleted = false;
mFirstRedraw = false;
mLastNormalizedTime = 0;
mLastAngle = 0;
mLastScale = 0;
mNeedsBlending = false;
const GraphicPlane& plane(graphicPlane(0));
mOriginalTargetOrientation = plane.getOrientation();
}
LayerOrientationAnimRotate::~LayerOrientationAnimRotate()
{
if (mTextureName != -1U) {
LayerBase::deletedTextures.add(mTextureName);
}
if (mTextureNameIn != -1U) {
LayerBase::deletedTextures.add(mTextureNameIn);
}
}
bool LayerOrientationAnimRotate::needsBlending() const
{
return mNeedsBlending;
}
Point LayerOrientationAnimRotate::getPhysicalSize() const
{
const GraphicPlane& plane(graphicPlane(0));
const DisplayHardware& hw(plane.displayHardware());
return Point(hw.getWidth(), hw.getHeight());
}
void LayerOrientationAnimRotate::validateVisibility(const Transform&)
{
const Layer::State& s(drawingState());
const Transform tr(s.transform);
const Point size(getPhysicalSize());
uint32_t w = size.x;
uint32_t h = size.y;
mTransformedBounds = tr.makeBounds(w, h);
mLeft = tr.tx();
mTop = tr.ty();
transparentRegionScreen.clear();
mTransformed = true;
mCanUseCopyBit = false;
}
void LayerOrientationAnimRotate::onOrientationCompleted()
{
mFinishTime = systemTime();
mOrientationCompleted = true;
mFirstRedraw = true;
mNeedsBlending = true;
mFlinger->invalidateLayerVisibility(this);
}
void LayerOrientationAnimRotate::onDraw(const Region& clip) const
{
// Animation...
const nsecs_t now = systemTime();
float angle, scale, alpha;
if (mOrientationCompleted) {
if (mFirstRedraw) {
// make a copy of what's on screen
copybit_image_t image;
mBitmapIn.getBitmapSurface(&image);
const DisplayHardware& hw(graphicPlane(0).displayHardware());
hw.copyBackToImage(image);
// FIXME: code below is gross
mFirstRedraw = false;
mNeedsBlending = false;
LayerOrientationAnimRotate* self(const_cast<LayerOrientationAnimRotate*>(this));
mFlinger->invalidateLayerVisibility(self);
}
// make sure pick-up where we left off
const float duration = DURATION * mLastNormalizedTime;
const float normalizedTime = (float(now - mFinishTime) / duration);
if (normalizedTime <= 1.0f) {
const float squaredTime = normalizedTime*normalizedTime;
angle = (ROTATION*ROTATION_FACTOR - mLastAngle)*squaredTime + mLastAngle;
scale = (1.0f - mLastScale)*squaredTime + mLastScale;
alpha = normalizedTime;
} else {
mAnim->onAnimationFinished();
angle = ROTATION;
alpha = 1.0f;
scale = 1.0f;
}
} else {
// FIXME: works only for portrait framebuffers
const Point size(getPhysicalSize());
const float TARGET_SCALE = size.x * (1.0f / size.y);
const float normalizedTime = float(now - mStartTime) / DURATION;
if (normalizedTime <= 1.0f) {
mLastNormalizedTime = normalizedTime;
const float squaredTime = normalizedTime*normalizedTime;
angle = ROTATION * squaredTime;
scale = (TARGET_SCALE - 1.0f)*squaredTime + 1.0f;
alpha = 0;
} else {
mLastNormalizedTime = 1.0f;
angle = ROTATION;
if (BOUNCES_AMPLITUDE) {
const float to_seconds = DURATION / seconds(1);
const float phi = BOUNCES_PER_SECOND *
(((normalizedTime - 1.0f) * to_seconds)*M_PI*2);
angle += BOUNCES_AMPLITUDE * sinf(phi);
}
scale = TARGET_SCALE;
alpha = 0;
}
mLastAngle = angle;
mLastScale = scale;
}
drawScaled(angle, scale, alpha);
}
void LayerOrientationAnimRotate::drawScaled(float f, float s, float alpha) const
{
copybit_image_t dst;
const GraphicPlane& plane(graphicPlane(0));
const DisplayHardware& hw(plane.displayHardware());
hw.getDisplaySurface(&dst);
// clear screen
// TODO: with update on demand, we may be able
// to not erase the screen at all during the animation
glDisable(GL_BLEND);
glDisable(GL_DITHER);
glDisable(GL_SCISSOR_TEST);
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
const int w = dst.w;
const int h = dst.h;
copybit_image_t src;
mBitmap.getBitmapSurface(&src);
const copybit_rect_t srect = { 0, 0, src.w, src.h };
GGLSurface t;
t.version = sizeof(GGLSurface);
t.width = src.w;
t.height = src.h;
t.stride = src.w;
t.vstride= src.h;
t.format = src.format;
t.data = (GGLubyte*)(intptr_t(src.base) + src.offset);
if (!mOriginalTargetOrientation) {
f = -f;
}
Transform tr;
tr.set(f, w*0.5f, h*0.5f);
tr.scale(s, w*0.5f, h*0.5f);
// FIXME: we should not access mVertices and mDrawingState like that,
// but since we control the animation, we know it's going to work okay.
// eventually we'd need a more formal way of doing things like this.
LayerOrientationAnimRotate& self(const_cast<LayerOrientationAnimRotate&>(*this));
tr.transform(self.mVertices[0], 0, 0);
tr.transform(self.mVertices[1], 0, src.h);
tr.transform(self.mVertices[2], src.w, src.h);
tr.transform(self.mVertices[3], src.w, 0);
if (!(mFlags & DisplayHardware::SLOW_CONFIG)) {
// Too slow to do this in software
self.mDrawingState.flags |= ISurfaceComposer::eLayerFilter;
}
if (UNLIKELY(mTextureName == -1LU)) {
mTextureName = createTexture();
GLuint w=0, h=0;
const Region dirty(Rect(t.width, t.height));
loadTexture(dirty, mTextureName, t, w, h);
}
self.mDrawingState.alpha = 255; //-int(alpha*255);
const Region clip(Rect( srect.l, srect.t, srect.r, srect.b ));
drawWithOpenGL(clip, mTextureName, t);
if (alpha > 0) {
const float sign = (!mOriginalTargetOrientation) ? 1.0f : -1.0f;
tr.set(f + sign*(M_PI * 0.5f * ROTATION_FACTOR), w*0.5f, h*0.5f);
tr.scale(s, w*0.5f, h*0.5f);
tr.transform(self.mVertices[0], 0, 0);
tr.transform(self.mVertices[1], 0, src.h);
tr.transform(self.mVertices[2], src.w, src.h);
tr.transform(self.mVertices[3], src.w, 0);
copybit_image_t src;
mBitmapIn.getBitmapSurface(&src);
t.data = (GGLubyte*)(intptr_t(src.base) + src.offset);
if (UNLIKELY(mTextureNameIn == -1LU)) {
mTextureNameIn = createTexture();
GLuint w=0, h=0;
const Region dirty(Rect(t.width, t.height));
loadTexture(dirty, mTextureNameIn, t, w, h);
}
self.mDrawingState.alpha = int(alpha*255);
const Region clip(Rect( srect.l, srect.t, srect.r, srect.b ));
drawWithOpenGL(clip, mTextureNameIn, t);
}
}
// ---------------------------------------------------------------------------
}; // namespace android

77
libs/surfaceflinger/LayerOrientationAnimRotate.h
View File

@@ -1,77 +0,0 @@
/*
* Copyright (C) 2007 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 ANDROID_LAYER_ORIENTATION_ANIM_ROTATE_H
#define ANDROID_LAYER_ORIENTATION_ANIM_ROTATE_H
#include <stdint.h>
#include <sys/types.h>
#include <utils/threads.h>
#include <utils/Parcel.h>
#include "LayerBase.h"
#include "LayerBitmap.h"
namespace android {
// ---------------------------------------------------------------------------
class OrientationAnimation;
class LayerOrientationAnimRotate : public LayerOrientationAnimBase
{
public:
static const uint32_t typeInfo;
static const char* const typeID;
virtual char const* getTypeID() const { return typeID; }
virtual uint32_t getTypeInfo() const { return typeInfo; }
LayerOrientationAnimRotate(SurfaceFlinger* flinger, DisplayID display,
OrientationAnimation* anim,
const LayerBitmap& zoomOut,
const LayerBitmap& zoomIn);
virtual ~LayerOrientationAnimRotate();
void onOrientationCompleted();
virtual void onDraw(const Region& clip) const;
virtual Point getPhysicalSize() const;
virtual void validateVisibility(const Transform& globalTransform);
virtual bool needsBlending() const;
virtual bool isSecure() const { return false; }
private:
void drawScaled(float angle, float scale, float alpha) const;
OrientationAnimation* mAnim;
LayerBitmap mBitmap;
LayerBitmap mBitmapIn;
nsecs_t mStartTime;
nsecs_t mFinishTime;
bool mOrientationCompleted;
int mOriginalTargetOrientation;
mutable bool mFirstRedraw;
mutable float mLastNormalizedTime;
mutable float mLastAngle;
mutable float mLastScale;
mutable GLuint mTextureName;
mutable GLuint mTextureNameIn;
mutable bool mNeedsBlending;
};
// ---------------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_LAYER_ORIENTATION_ANIM_ROTATE_H

12
libs/surfaceflinger/OrientationAnimation.cpp
View File

@@ -21,7 +21,6 @@
#include <limits.h>
#include "LayerOrientationAnim.h"
#include "LayerOrientationAnimRotate.h"
#include "OrientationAnimation.h"
#include "SurfaceFlinger.h"
#include "VRamHeap.h"
@@ -112,13 +111,8 @@ bool OrientationAnimation::prepare()
LayerOrientationAnimBase* l;
if (mType & 0x80) {
l = new LayerOrientationAnimRotate(
mFlinger.get(), 0, this, bitmap, bitmapIn);
} else {
l = new LayerOrientationAnim(
mFlinger.get(), 0, this, bitmap, bitmapIn);
}
l = new LayerOrientationAnim(
mFlinger.get(), 0, this, bitmap, bitmapIn);
l->initStates(w, h, 0);
l->setLayer(INT_MAX-1);
@@ -137,7 +131,7 @@ bool OrientationAnimation::phase1()
return true;
}
mLayerOrientationAnim->invalidate();
//mLayerOrientationAnim->invalidate();
return false;
}