Automated import from //branches/cupcake/...@142856,142856
diff --git a/libs/surfaceflinger/LayerOrientationAnim.cpp b/libs/surfaceflinger/LayerOrientationAnim.cpp
index 2b72d7c..3e4035e 100644
--- a/libs/surfaceflinger/LayerOrientationAnim.cpp
+++ b/libs/surfaceflinger/LayerOrientationAnim.cpp
@@ -22,11 +22,13 @@
#include <utils/Errors.h>
#include <utils/Log.h>
+#include <utils/StopWatch.h>
#include <core/SkBitmap.h>
#include <ui/EGLDisplaySurface.h>
+#include "BlurFilter.h"
#include "LayerBase.h"
#include "LayerOrientationAnim.h"
#include "SurfaceFlinger.h"
@@ -41,22 +43,35 @@
// ---------------------------------------------------------------------------
+// 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)
+
+// ---------------------------------------------------------------------------
+
LayerOrientationAnim::LayerOrientationAnim(
SurfaceFlinger* flinger, DisplayID display,
OrientationAnimation* anim,
- const LayerBitmap& bitmap,
- const LayerBitmap& bitmapIn)
- : LayerBase(flinger, display), mAnim(anim),
- mBitmap(bitmap), mBitmapIn(bitmapIn),
+ const LayerBitmap& bitmapIn,
+ const LayerBitmap& bitmapOut)
+ : LayerOrientationAnimBase(flinger, display), mAnim(anim),
+ mBitmapIn(bitmapIn), mBitmapOut(bitmapOut),
mTextureName(-1), mTextureNameIn(-1)
{
+ // blur that texture.
mStartTime = systemTime();
mFinishTime = 0;
mOrientationCompleted = false;
mFirstRedraw = false;
mLastNormalizedTime = 0;
- mLastScale = 0;
mNeedsBlending = false;
+ mAlphaInLerp.set(1.0f, DIM_TARGET);
+ mAlphaOutLerp.set(0.5f, 1.0f);
}
LayerOrientationAnim::~LayerOrientationAnim()
@@ -111,14 +126,8 @@
void LayerOrientationAnim::onDraw(const Region& clip) const
{
- // Animation...
- const float MIN_SCALE = 0.5f;
- const float DURATION = ms2ns(200);
- const float BOUNCES_PER_SECOND = 1.618f;
- const float BOUNCES_AMPLITUDE = 1.0f/32.0f;
-
const nsecs_t now = systemTime();
- float scale, alpha;
+ float alphaIn, alphaOut;
if (mOrientationCompleted) {
if (mFirstRedraw) {
@@ -126,7 +135,7 @@
// make a copy of what's on screen
copybit_image_t image;
- mBitmapIn.getBitmapSurface(&image);
+ mBitmapOut.getBitmapSurface(&image);
const DisplayHardware& hw(graphicPlane(0).displayHardware());
hw.copyBackToImage(image);
@@ -147,37 +156,40 @@
const float duration = DURATION * mLastNormalizedTime;
const float normalizedTime = (float(now - mFinishTime) / duration);
if (normalizedTime <= 1.0f) {
- const float squaredTime = normalizedTime*normalizedTime;
- scale = (1.0f - mLastScale)*squaredTime + mLastScale;
- alpha = (1.0f - normalizedTime);
- alpha *= alpha;
- alpha *= alpha;
+ const float interpolatedTime = INTERPOLATED_TIME(normalizedTime);
+ alphaIn = mAlphaInLerp.getOut();
+ alphaOut = mAlphaOutLerp(interpolatedTime);
} else {
mAnim->onAnimationFinished();
- scale = 1.0f;
- alpha = 0.0f;
+ alphaIn = mAlphaInLerp.getOut();
+ alphaOut = mAlphaOutLerp.getOut();
}
} else {
const float normalizedTime = float(now - mStartTime) / DURATION;
if (normalizedTime <= 1.0f) {
mLastNormalizedTime = normalizedTime;
- const float squaredTime = normalizedTime*normalizedTime;
- scale = (MIN_SCALE-1.0f)*squaredTime + 1.0f;
- alpha = 1.0f;
+ const float interpolatedTime = INTERPOLATED_TIME(normalizedTime);
+ alphaIn = mAlphaInLerp(interpolatedTime);
+ alphaOut = 0.0f;
} else {
mLastNormalizedTime = 1.0f;
const float to_seconds = DURATION / seconds(1);
- const float phi = BOUNCES_PER_SECOND *
- (((normalizedTime - 1.0f) * to_seconds)*M_PI*2);
- scale = MIN_SCALE + BOUNCES_AMPLITUDE * (1.0f - cosf(phi));
- alpha = 1.0f;
+ 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;
}
- mLastScale = scale;
+ mAlphaOutLerp.setIn(alphaIn);
}
- drawScaled(scale, alpha);
+ drawScaled(1.0f, alphaIn, alphaOut);
}
-void LayerOrientationAnim::drawScaled(float f, float alpha) const
+void LayerOrientationAnim::drawScaled(float scale, float alphaIn, float alphaOut) const
{
copybit_image_t dst;
const GraphicPlane& plane(graphicPlane(0));
@@ -188,22 +200,30 @@
// 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);
+ 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);
+ }
}
- const int w = dst.w*f;
- const int h = dst.h*f;
+ 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 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 };
-
- copybit_image_t src;
- mBitmap.getBitmapSurface(&src);
const copybit_rect_t srect = { 0, 0, src.w, src.h };
+ const Region reg(Rect( drect.l, drect.t, drect.r, drect.b ));
int err = NO_ERROR;
const int can_use_copybit = canUseCopybit();
@@ -211,19 +231,19 @@
copybit_device_t* copybit = mFlinger->getBlitEngine();
copybit->set_parameter(copybit, COPYBIT_TRANSFORM, 0);
copybit->set_parameter(copybit, COPYBIT_DITHER, COPYBIT_ENABLE);
-
- if (alpha < 1.0f) {
- copybit_image_t srcIn;
- mBitmapIn.getBitmapSurface(&srcIn);
- region_iterator it(Region(Rect( drect.l, drect.t, drect.r, drect.b )));
- copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 0xFF);
- err = copybit->stretch(copybit, &dst, &srcIn, &drect, &srect, &it);
+
+ if (alphaIn > 0) {
+ region_iterator it(reg);
+ 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 && alpha > 0.0f) {
- region_iterator it(Region(Rect( drect.l, drect.t, drect.r, drect.b )));
- copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, int(alpha*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));
}
@@ -238,7 +258,7 @@
t.data = (GGLubyte*)(intptr_t(src.base) + src.offset);
Transform tr;
- tr.set(f,0,0,f);
+ tr.set(scale,0,0,scale);
tr.set(xc, yc);
// FIXME: we should not access mVertices and mDrawingState like that,
@@ -254,9 +274,7 @@
self.mDrawingState.flags |= ISurfaceComposer::eLayerFilter;
}
- if (alpha < 1.0f) {
- copybit_image_t src;
- mBitmapIn.getBitmapSurface(&src);
+ if (alphaIn > 0.0f) {
t.data = (GGLubyte*)(intptr_t(src.base) + src.offset);
if (UNLIKELY(mTextureNameIn == -1LU)) {
mTextureNameIn = createTexture();
@@ -264,21 +282,21 @@
const Region dirty(Rect(t.width, t.height));
loadTexture(dirty, mTextureNameIn, t, w, h);
}
- self.mDrawingState.alpha = 255;
- const Region clip(Rect( drect.l, drect.t, drect.r, drect.b ));
- drawWithOpenGL(clip, mTextureName, t);
+ self.mDrawingState.alpha = int(alphaIn*255);
+ drawWithOpenGL(reg, mTextureNameIn, t);
}
- t.data = (GGLubyte*)(intptr_t(src.base) + src.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);
+ 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);
}
- self.mDrawingState.alpha = int(alpha*255);
- const Region clip(Rect( drect.l, drect.t, drect.r, drect.b ));
- drawWithOpenGL(clip, mTextureName, t);
}
}