| /* |
| * 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 <utils/StopWatch.h> |
| |
| #include "BlurFilter.h" |
| #include "LayerBase.h" |
| #include "LayerOrientationAnim.h" |
| #include "SurfaceFlinger.h" |
| #include "DisplayHardware/DisplayHardware.h" |
| #include "OrientationAnimation.h" |
| |
| namespace android { |
| // --------------------------------------------------------------------------- |
| |
| const uint32_t LayerOrientationAnim::typeInfo = LayerBase::typeInfo | 0x80; |
| 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) |
| |
| // --------------------------------------------------------------------------- |
| |
| LayerOrientationAnim::LayerOrientationAnim( |
| SurfaceFlinger* flinger, DisplayID display, |
| OrientationAnimation* anim, |
| const sp<Buffer>& bitmapIn, |
| const sp<Buffer>& 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; |
| mNeedsBlending = false; |
| mAlphaInLerp.set(1.0f, DIM_TARGET); |
| mAlphaOutLerp.set(0.5f, 1.0f); |
| } |
| |
| LayerOrientationAnim::~LayerOrientationAnim() |
| { |
| if (mTextureName != -1U) { |
| glDeleteTextures(1, &mTextureName); |
| } |
| if (mTextureNameIn != -1U) { |
| glDeleteTextures(1, &mTextureNameIn); |
| } |
| } |
| |
| bool LayerOrientationAnim::needsBlending() const |
| { |
| return mNeedsBlending; |
| } |
| |
| Point LayerOrientationAnim::getPhysicalSize() const |
| { |
| const GraphicPlane& plane(graphicPlane(0)); |
| const DisplayHardware& hw(plane.displayHardware()); |
| return Point(hw.getWidth(), hw.getHeight()); |
| } |
| |
| void LayerOrientationAnim::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; |
| } |
| |
| void LayerOrientationAnim::onOrientationCompleted() |
| { |
| mFinishTime = systemTime(); |
| mOrientationCompleted = true; |
| mFirstRedraw = true; |
| mNeedsBlending = true; |
| mFlinger->invalidateLayerVisibility(this); |
| } |
| |
| 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); |
| |
| // 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); |
| } |
| 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 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 }; |
| const copybit_rect_t srect = { 0, 0, src.w, src.h }; |
| const Region reg(Rect( drect.l, drect.t, drect.r, drect.b )); |
| |
| 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); |
| |
| Transform tr; |
| tr.set(scale,0,0,scale); |
| tr.set(xc, yc); |
| |
| // 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. |
| LayerOrientationAnim& self(const_cast<LayerOrientationAnim&>(*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 (alphaIn > 0.0f) { |
| 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(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); |
| } |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| }; // namespace android |