Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8f87f20a authored by Android (Google) Code Review's avatar Android (Google) Code Review
Browse files

Merge change 6862 into donut 

* changes:
  fix [1967226] Donut orientation animation (dimming and blur) is slower than Cupcake
parents 6ab0e573 5cd5d31d

libs/surfaceflinger/Android.mk

+0 −1
Original line number Diff line number Diff line
@@ -15,7 +15,6 @@ LOCAL_SRC_FILES:= \ 
    LayerBitmap.cpp \

    LayerDim.cpp \

    LayerOrientationAnim.cpp \

    LayerOrientationAnimRotate.cpp \

    OrientationAnimation.cpp \

    SurfaceFlinger.cpp \

    Tokenizer.cpp \

libs/surfaceflinger/LayerOrientationAnim.cpp

+14 −113
Original line number Diff line number Diff line
@@ -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;

    

    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);

    float alphaIn =  DIM_TARGET;

    

            // and erase the screen for this round

    // 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);

            

            // 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);

    }

    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);

        }

    }

}

libs/surfaceflinger/LayerOrientationAnim.h

+0 −32
Original line number Diff line number Diff line
@@ -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;

};



// ---------------------------------------------------------------------------

libs/surfaceflinger/LayerOrientationAnimRotate.cpp

deleted100644 → 0
+0 −274
Original line number Diff line number Diff line 
/*

 * 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

libs/surfaceflinger/LayerOrientationAnimRotate.h

deleted100644 → 0
+0 −77
Original line number Diff line number Diff line 
/*

 * 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