diff options
author | Mathias Agopian <mathias@google.com> | 2010-02-23 12:52:28 -0800 |
---|---|---|
committer | Android (Google) Code Review <android-gerrit@google.com> | 2010-02-23 12:52:28 -0800 |
commit | 80bd6a16379a009fbad697fe1c4ffabe0f2630ff (patch) | |
tree | 15bfe1c508d2358a21272c4662b12438de028fad /libs | |
parent | aff2e1b71c74776079df6adc06e6e8d5f123eeb6 (diff) | |
parent | 8c20ca39c1248bc876ab164b37ae36261c86ad98 (diff) | |
download | frameworks_base-80bd6a16379a009fbad697fe1c4ffabe0f2630ff.zip frameworks_base-80bd6a16379a009fbad697fe1c4ffabe0f2630ff.tar.gz frameworks_base-80bd6a16379a009fbad697fe1c4ffabe0f2630ff.tar.bz2 |
Merge "remove a dependency of surfaceflinger on libskia"
Diffstat (limited to 'libs')
-rw-r--r-- | libs/surfaceflinger/Android.mk | 1 | ||||
-rw-r--r-- | libs/surfaceflinger/LayerBase.h | 1 | ||||
-rw-r--r-- | libs/surfaceflinger/SurfaceFlinger.cpp | 45 | ||||
-rw-r--r-- | libs/surfaceflinger/Transform.cpp | 390 | ||||
-rw-r--r-- | libs/surfaceflinger/Transform.h | 94 |
5 files changed, 351 insertions, 180 deletions
diff --git a/libs/surfaceflinger/Android.mk b/libs/surfaceflinger/Android.mk index 395a937..86eb78d 100644 --- a/libs/surfaceflinger/Android.mk +++ b/libs/surfaceflinger/Android.mk @@ -35,7 +35,6 @@ LOCAL_SHARED_LIBRARIES := \ libpixelflinger \ libhardware \ libutils \ - libskia \ libEGL \ libGLESv1_CM \ libbinder \ diff --git a/libs/surfaceflinger/LayerBase.h b/libs/surfaceflinger/LayerBase.h index d1bbd04..6aacd82 100644 --- a/libs/surfaceflinger/LayerBase.h +++ b/libs/surfaceflinger/LayerBase.h @@ -22,6 +22,7 @@ #include <EGL/egl.h> #include <EGL/eglext.h> +#include <GLES/gl.h> #include <utils/RefBase.h> diff --git a/libs/surfaceflinger/SurfaceFlinger.cpp b/libs/surfaceflinger/SurfaceFlinger.cpp index 2d6152e..b408779 100644 --- a/libs/surfaceflinger/SurfaceFlinger.cpp +++ b/libs/surfaceflinger/SurfaceFlinger.cpp @@ -1496,8 +1496,8 @@ status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args) layer->needsBlending(), layer->needsDithering(), layer->contentDirty, s.alpha, s.flags, - s.transform[0], s.transform[1], - s.transform[2], s.transform[3]); + s.transform[0][0], s.transform[0][1], + s.transform[1][0], s.transform[1][1]); result.append(buffer); buffer[0] = 0; /*** LayerBaseClient ***/ @@ -1833,27 +1833,25 @@ void GraphicPlane::setDisplayHardware(DisplayHardware *hw) status_t GraphicPlane::orientationToTransfrom( int orientation, int w, int h, Transform* tr) -{ - float a, b, c, d, x, y; +{ + uint32_t flags = 0; switch (orientation) { case ISurfaceComposer::eOrientationDefault: - // make sure the default orientation is optimal - tr->reset(); - return NO_ERROR; + flags = Transform::ROT_0; + break; case ISurfaceComposer::eOrientation90: - a=0; b=-1; c=1; d=0; x=w; y=0; + flags = Transform::ROT_90; break; case ISurfaceComposer::eOrientation180: - a=-1; b=0; c=0; d=-1; x=w; y=h; + flags = Transform::ROT_180; break; case ISurfaceComposer::eOrientation270: - a=0; b=1; c=-1; d=0; x=0; y=h; + flags = Transform::ROT_270; break; default: return BAD_VALUE; } - tr->set(a, b, c, d); - tr->set(x, y); + tr->set(flags, w, h); return NO_ERROR; } @@ -1869,24 +1867,13 @@ status_t GraphicPlane::setOrientation(int orientation) mHeight = int(h); Transform orientationTransform; - if (UNLIKELY(orientation == 42)) { - float a, b, c, d, x, y; - const float r = (3.14159265f / 180.0f) * 42.0f; - const float si = sinf(r); - const float co = cosf(r); - a=co; b=-si; c=si; d=co; - x = si*(h*0.5f) + (1-co)*(w*0.5f); - y =-si*(w*0.5f) + (1-co)*(h*0.5f); - orientationTransform.set(a, b, c, d); - orientationTransform.set(x, y); - } else { - GraphicPlane::orientationToTransfrom(orientation, w, h, - &orientationTransform); - if (orientation & ISurfaceComposer::eOrientationSwapMask) { - mWidth = int(h); - mHeight = int(w); - } + GraphicPlane::orientationToTransfrom(orientation, w, h, + &orientationTransform); + if (orientation & ISurfaceComposer::eOrientationSwapMask) { + mWidth = int(h); + mHeight = int(w); } + mOrientation = orientation; mGlobalTransform = mDisplayTransform * orientationTransform; return NO_ERROR; diff --git a/libs/surfaceflinger/Transform.cpp b/libs/surfaceflinger/Transform.cpp index ab6f7ba..b2d5856 100644 --- a/libs/surfaceflinger/Transform.cpp +++ b/libs/surfaceflinger/Transform.cpp @@ -14,180 +14,257 @@ * limitations under the License. */ -#include <ui/Region.h> +#include <math.h> -#include <private/pixelflinger/ggl_fixed.h> +#include <cutils/compiler.h> +#include <utils/String8.h> +#include <ui/Region.h> #include "Transform.h" // --------------------------------------------------------------------------- -#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) -#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) +namespace android { // --------------------------------------------------------------------------- -namespace android { +template <typename T> inline T min(T a, T b) { + return a<b ? a : b; +} +template <typename T> inline T min(T a, T b, T c) { + return min(a, min(b, c)); +} +template <typename T> inline T min(T a, T b, T c, T d) { + return min(a, b, min(c, d)); +} + +template <typename T> inline T max(T a, T b) { + return a>b ? a : b; +} +template <typename T> inline T max(T a, T b, T c) { + return max(a, max(b, c)); +} +template <typename T> inline T max(T a, T b, T c, T d) { + return max(a, b, max(c, d)); +} // --------------------------------------------------------------------------- -Transform::Transform() - : mType(0) -{ - mTransform.reset(); +Transform::Transform() { + reset(); } Transform::Transform(const Transform& other) - : mTransform(other.mTransform), mType(other.mType) -{ + : mMatrix(other.mMatrix), mType(other.mType) { } -Transform::Transform(int32_t flags) { - mTransform.reset(); - int sx = (flags & FLIP_H) ? -1 : 1; - int sy = (flags & FLIP_V) ? -1 : 1; - if (flags & ROT_90) { - this->set(0, -sy, sx, 0); - } else { - this->set(sx, 0, 0, sy); - } +Transform::Transform(uint32_t orientation) { + set(orientation, 0, 0); } Transform::~Transform() { } + +bool Transform::absIsOne(float f) { + return fabs(f) == 1.0f; +} + +bool Transform::isZero(float f) { + return fabs(f) == 0.0f; +} + +bool Transform::absEqual(float a, float b) { + return fabs(a) == fabs(b); +} + Transform Transform::operator * (const Transform& rhs) const { - if (LIKELY(mType == 0)) + if (CC_LIKELY(mType == IDENTITY)) return rhs; Transform r(*this); - r.mTransform.preConcat(rhs.mTransform); + if (rhs.mType == IDENTITY) + return r; + + // TODO: we could use mType to optimize the matrix multiply + const mat33& A(mMatrix); + const mat33& B(rhs.mMatrix); + mat33& D(r.mMatrix); + for (int i=0 ; i<3 ; i++) { + const float v0 = A[0][i]; + const float v1 = A[1][i]; + const float v2 = A[2][i]; + D[0][i] = v0*B[0][0] + v1*B[0][1] + v2*B[0][2]; + D[1][i] = v0*B[1][0] + v1*B[1][1] + v2*B[1][2]; + D[2][i] = v0*B[2][0] + v1*B[2][1] + v2*B[2][2]; + } r.mType |= rhs.mType; - return r; -} -float Transform::operator [] (int i) const -{ - float r = 0; - switch(i) { - case 0: r = SkScalarToFloat( mTransform[SkMatrix::kMScaleX] ); break; - case 1: r = SkScalarToFloat( mTransform[SkMatrix::kMSkewX] ); break; - case 2: r = SkScalarToFloat( mTransform[SkMatrix::kMSkewY] ); break; - case 3: r = SkScalarToFloat( mTransform[SkMatrix::kMScaleY] ); break; - } + // TODO: we could recompute this value from r and rhs + r.mType &= 0xFF; + r.mType |= UNKNOWN_TYPE; return r; } -uint8_t Transform::type() const -{ - if (UNLIKELY(mType & 0x80000000)) { - mType = mTransform.getType(); - } - return uint8_t(mType & 0xFF); +float const* Transform::operator [] (int i) const { + return mMatrix[i].v; } bool Transform::transformed() const { - return type() > SkMatrix::kTranslate_Mask; + return type() > TRANSLATE; } int Transform::tx() const { - return SkScalarRound( mTransform[SkMatrix::kMTransX] ); + return floorf(mMatrix[2][0] + 0.5f); } int Transform::ty() const { - return SkScalarRound( mTransform[SkMatrix::kMTransY] ); + return floorf(mMatrix[2][1] + 0.5f); } void Transform::reset() { - mTransform.reset(); - mType = 0; + mType = IDENTITY; + for(int i=0 ; i<3 ; i++) { + vec3& v(mMatrix[i]); + for (int j=0 ; j<3 ; j++) + v[j] = ((i==j) ? 1.0f : 0.0f); + } } -void Transform::set( float xx, float xy, - float yx, float yy) +void Transform::set(float tx, float ty) { - mTransform.set(SkMatrix::kMScaleX, SkFloatToScalar(xx)); - mTransform.set(SkMatrix::kMSkewX, SkFloatToScalar(xy)); - mTransform.set(SkMatrix::kMSkewY, SkFloatToScalar(yx)); - mTransform.set(SkMatrix::kMScaleY, SkFloatToScalar(yy)); - mType |= 0x80000000; + mMatrix[2][0] = tx; + mMatrix[2][1] = ty; + mMatrix[2][2] = 1.0f; + + if (isZero(tx) && isZero(ty)) { + mType &= ~TRANSLATE; + } else { + mType |= TRANSLATE; + } } -void Transform::set(float radian, float x, float y) -{ - float r00 = cosf(radian); float r01 = -sinf(radian); - float r10 = sinf(radian); float r11 = cosf(radian); - mTransform.set(SkMatrix::kMScaleX, SkFloatToScalar(r00)); - mTransform.set(SkMatrix::kMSkewX, SkFloatToScalar(r01)); - mTransform.set(SkMatrix::kMSkewY, SkFloatToScalar(r10)); - mTransform.set(SkMatrix::kMScaleY, SkFloatToScalar(r11)); - mTransform.set(SkMatrix::kMTransX, SkIntToScalar(x - r00*x - r01*y)); - mTransform.set(SkMatrix::kMTransY, SkIntToScalar(y - r10*x - r11*y)); - mType |= 0x80000000 | SkMatrix::kTranslate_Mask; -} - -void Transform::scale(float s, float x, float y) +void Transform::set(float a, float b, float c, float d) { - mTransform.postScale(s, s, x, y); - mType |= 0x80000000; + mat33& M(mMatrix); + M[0][0] = a; M[1][0] = b; + M[0][1] = c; M[1][1] = d; + M[0][2] = 0; M[1][2] = 0; + mType = UNKNOWN_TYPE; } -void Transform::set(int tx, int ty) +void Transform::set(uint32_t flags, float w, float h) { - if (tx | ty) { - mTransform.set(SkMatrix::kMTransX, SkIntToScalar(tx)); - mTransform.set(SkMatrix::kMTransY, SkIntToScalar(ty)); - mType |= SkMatrix::kTranslate_Mask; + mType = flags << 8; + float sx = (flags & FLIP_H) ? -1 : 1; + float sy = (flags & FLIP_V) ? -1 : 1; + float a=0, b=0, c=0, d=0, x=0, y=0; + int xmask = 0; + + // computation of x,y + // x y + // 0 0 0 + // w 0 ROT90 + // w h FLIPH|FLIPV + // 0 h FLIPH|FLIPV|ROT90 + + if (flags & ROT_90) { + mType |= ROTATE; + b = -sy; + c = sx; + xmask = 1; } else { - mTransform.set(SkMatrix::kMTransX, 0); - mTransform.set(SkMatrix::kMTransY, 0); - mType &= ~SkMatrix::kTranslate_Mask; + a = sx; + d = sy; } + + if (flags & FLIP_H) { + mType ^= SCALE; + xmask ^= 1; + } + + if (flags & FLIP_V) { + mType ^= SCALE; + y = h; + } + + if ((flags & ROT_180) == ROT_180) { + mType |= ROTATE; + } + + if (xmask) { + x = w; + } + + if (!isZero(x) || !isZero(y)) { + mType |= TRANSLATE; + } + + mat33& M(mMatrix); + M[0][0] = a; M[1][0] = b; M[2][0] = x; + M[0][1] = c; M[1][1] = d; M[2][1] = y; + M[0][2] = 0; M[1][2] = 0; M[2][2] = 1; +} + +Transform::vec2 Transform::transform(const vec2& v) const { + vec2 r; + const mat33& M(mMatrix); + r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0]; + r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1]; + return r; } -void Transform::transform(GLfixed* point, int x, int y) const +Transform::vec3 Transform::transform(const vec3& v) const { + vec3 r; + const mat33& M(mMatrix); + r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0]*v[2]; + r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1]*v[2]; + r[2] = M[0][2]*v[0] + M[1][2]*v[1] + M[2][2]*v[2]; + return r; +} + +void Transform::transform(fixed1616* point, int x, int y) const { - SkPoint s; - mTransform.mapXY(SkIntToScalar(x), SkIntToScalar(y), &s); - point[0] = SkScalarToFixed(s.fX); - point[1] = SkScalarToFixed(s.fY); + const float toFixed = 65536.0f; + const mat33& M(mMatrix); + vec2 v(x, y); + v = transform(v); + point[0] = v[0] * toFixed; + point[1] = v[1] * toFixed; } Rect Transform::makeBounds(int w, int h) const { - Rect r; - SkRect d, s; - s.set(0, 0, SkIntToScalar(w), SkIntToScalar(h)); - mTransform.mapRect(&d, s); - r.left = SkScalarRound( d.fLeft ); - r.top = SkScalarRound( d.fTop ); - r.right = SkScalarRound( d.fRight ); - r.bottom = SkScalarRound( d.fBottom ); - return r; + return transform( Rect(w, h) ); } Rect Transform::transform(const Rect& bounds) const { Rect r; - SkRect d, s; - s.set( SkIntToScalar( bounds.left ), - SkIntToScalar( bounds.top ), - SkIntToScalar( bounds.right ), - SkIntToScalar( bounds.bottom )); - mTransform.mapRect(&d, s); - r.left = SkScalarRound( d.fLeft ); - r.top = SkScalarRound( d.fTop ); - r.right = SkScalarRound( d.fRight ); - r.bottom = SkScalarRound( d.fBottom ); + vec2 lt( bounds.left, bounds.top ); + vec2 rt( bounds.right, bounds.top ); + vec2 lb( bounds.left, bounds.bottom ); + vec2 rb( bounds.right, bounds.bottom ); + + lt = transform(lt); + rt = transform(rt); + lb = transform(lb); + rb = transform(rb); + + r.left = floorf(min(lt[0], rt[0], lb[0], rb[0]) + 0.5f); + r.top = floorf(min(lt[1], rt[1], lb[1], rb[1]) + 0.5f); + r.right = floorf(max(lt[0], rt[0], lb[0], rb[0]) + 0.5f); + r.bottom = floorf(max(lt[1], rt[1], lb[1], rb[1]) + 0.5f); + return r; } Region Transform::transform(const Region& reg) const { Region out; - if (UNLIKELY(transformed())) { - if (LIKELY(preserveRects())) { + if (CC_UNLIKELY(transformed())) { + if (CC_LIKELY(preserveRects())) { Region::const_iterator it = reg.begin(); Region::const_iterator const end = reg.end(); while (it != end) { @@ -202,31 +279,108 @@ Region Transform::transform(const Region& reg) const return out; } -int32_t Transform::getOrientation() const +uint32_t Transform::type() const { - uint32_t flags = 0; - if (UNLIKELY(transformed())) { - SkScalar a = mTransform[SkMatrix::kMScaleX]; - SkScalar b = mTransform[SkMatrix::kMSkewX]; - SkScalar c = mTransform[SkMatrix::kMSkewY]; - SkScalar d = mTransform[SkMatrix::kMScaleY]; - if (b==0 && c==0 && a && d) { - if (a<0) flags |= FLIP_H; - if (d<0) flags |= FLIP_V; - } else if (b && c && a==0 && d==0) { - flags |= ROT_90; - if (b>0) flags |= FLIP_H; - if (c<0) flags |= FLIP_V; + if (mType & UNKNOWN_TYPE) { + // recompute what this transform is + + const mat33& M(mMatrix); + const float a = M[0][0]; + const float b = M[1][0]; + const float c = M[0][1]; + const float d = M[1][1]; + const float x = M[2][0]; + const float y = M[2][1]; + + bool scale = false; + uint32_t flags = ROT_0; + if (isZero(b) && isZero(c)) { + if (absEqual(a, d)) { + if (a<0) flags |= FLIP_H; + if (d<0) flags |= FLIP_V; + if (!absIsOne(a) || !absIsOne(d)) { + scale = true; + } + } else { + flags = ROT_INVALID; + } + } else if (isZero(a) && isZero(d)) { + if (absEqual(b, c)) { + flags |= ROT_90; + if (b>0) flags |= FLIP_H; + if (c<0) flags |= FLIP_V; + if (!absIsOne(b) || !absIsOne(c)) { + scale = true; + } + } else { + flags = ROT_INVALID; + } + } else { + flags = ROT_INVALID; + } + + mType = flags << 8; + if (flags & ROT_INVALID) { + mType |= UNKNOWN; } else { - flags = 0x80000000; + if ((flags & ROT_90) || ((flags & ROT_180) == ROT_180)) + mType |= ROTATE; + if (flags & FLIP_H) + mType ^= SCALE; + if (flags & FLIP_V) + mType ^= SCALE; + if (scale) + mType |= SCALE; } + + if (!isZero(x) || !isZero(y)) + mType |= TRANSLATE; } - return flags; + return mType; +} + +uint32_t Transform::getType() const { + return type() & 0xFF; +} + +uint32_t Transform::getOrientation() const +{ + return (type() >> 8) & 0xFF; } bool Transform::preserveRects() const { - return mTransform.rectStaysRect(); + return (type() & ROT_INVALID) ? false : true; +} + +void Transform::dump(const char* name) const +{ + type(); // updates the type + + String8 flags, type; + const mat33& m(mMatrix); + uint32_t orient = mType >> 8; + + if (orient&ROT_INVALID) + flags.append("ROT_INVALID "); + if (orient&ROT_90) + flags.append("ROT_90 "); + if (orient&FLIP_V) + flags.append("FLIP_V "); + if (orient&FLIP_H) + flags.append("FLIP_H "); + + if (mType&SCALE) + type.append("SCALE "); + if (mType&ROTATE) + type.append("ROTATE "); + if (mType&TRANSLATE) + type.append("TRANSLATE "); + + LOGD("%s (%s, %s)", name, flags.string(), type.string()); + LOGD("%.2f %.2f %.2f", m[0][0], m[1][0], m[2][0]); + LOGD("%.2f %.2f %.2f", m[0][1], m[1][1], m[2][1]); + LOGD("%.2f %.2f %.2f", m[0][2], m[1][2], m[2][2]); } // --------------------------------------------------------------------------- diff --git a/libs/surfaceflinger/Transform.h b/libs/surfaceflinger/Transform.h index ddab404..51d3e3f 100644 --- a/libs/surfaceflinger/Transform.h +++ b/libs/surfaceflinger/Transform.h @@ -23,10 +23,6 @@ #include <ui/Point.h> #include <ui/Rect.h> -#include <GLES/gl.h> - -#include <core/SkMatrix.h> - namespace android { class Region; @@ -38,9 +34,12 @@ class Transform public: Transform(); Transform(const Transform& other); - Transform(int32_t flags); + explicit Transform(uint32_t orientation); ~Transform(); + typedef int32_t fixed1616; + + // FIXME: must match OVERLAY_TRANSFORM_*, pull from hardware.h enum orientation_flags { ROT_0 = 0x00000000, FLIP_H = 0x00000001, @@ -48,48 +47,79 @@ public: ROT_90 = 0x00000004, ROT_180 = FLIP_H|FLIP_V, ROT_270 = ROT_180|ROT_90, - ROT_INVALID = 0x80000000 + ROT_INVALID = 0x80 }; enum type_mask { IDENTITY = 0, TRANSLATE = 0x1, - SCALE = 0x2, - AFFINE = 0x4, - PERSPECTIVE = 0x8 + ROTATE = 0x2, + SCALE = 0x4, + UNKNOWN = 0x8 }; - bool transformed() const; - int32_t getOrientation() const; - bool preserveRects() const; - + // query the transform + bool transformed() const; + bool preserveRects() const; + uint32_t getType() const; + uint32_t getOrientation() const; + + float const* operator [] (int i) const; // returns column i int tx() const; int ty() const; - + + // modify the transform void reset(); - void set(float xx, float xy, float yx, float yy); - void set(int tx, int ty); - void set(float radian, float x, float y); - void scale(float s, float x, float y); - + void set(float tx, float ty); + void set(float a, float b, float c, float d); + void set(uint32_t flags, float w, float h); + + // transform data Rect makeBounds(int w, int h) const; - void transform(GLfixed* point, int x, int y) const; + void transform(fixed1616* point, int x, int y) const; Region transform(const Region& reg) const; - Rect transform(const Rect& bounds) const; - Transform operator * (const Transform& rhs) const; - float operator [] (int i) const; - - inline uint32_t getType() const { return type(); } - - inline Transform(bool) : mType(0xFF) { }; - -private: - uint8_t type() const; private: - SkMatrix mTransform; - mutable uint32_t mType; + struct vec3 { + float v[3]; + inline vec3() { } + inline vec3(float a, float b, float c) { + v[0] = a; v[1] = b; v[2] = c; + } + inline float operator [] (int i) const { return v[i]; } + inline float& operator [] (int i) { return v[i]; } + }; + struct vec2 { + float v[2]; + inline vec2() { } + inline vec2(float a, float b) { + v[0] = a; v[1] = b; + } + inline float operator [] (int i) const { return v[i]; } + inline float& operator [] (int i) { return v[i]; } + }; + struct mat33 { + vec3 v[3]; + inline const vec3& operator [] (int i) const { return v[i]; } + inline vec3& operator [] (int i) { return v[i]; } + }; + + enum { UNKNOWN_TYPE = 0x80000000 }; + + // assumes the last row is < 0 , 0 , 1 > + vec2 transform(const vec2& v) const; + vec3 transform(const vec3& v) const; + Rect transform(const Rect& bounds) const; + uint32_t type() const; + static bool absIsOne(float f); + static bool absEqual(float a, float b); + static bool isZero(float f); + + void dump(const char* name) const; + + mat33 mMatrix; + mutable uint32_t mType; }; // --------------------------------------------------------------------------- |