Merge "remove a dependency of surfaceflinger on libskia" (0d3cdb66) · Commits · e / os / android_frameworks_native-old

libs/surfaceflinger/Android.mk

+0 −1

Original line number	Diff line number	Diff line
		@@ -35,7 +35,6 @@ LOCAL_SHARED_LIBRARIES := \
		libpixelflinger \
		libhardware \
		libutils \
		libskia \
		libEGL \
		libGLESv1_CM \
		libbinder \

libs/surfaceflinger/LayerBase.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@

		#include <EGL/egl.h>
		#include <EGL/eglext.h>
		#include <GLES/gl.h>

		#include <utils/RefBase.h>

libs/surfaceflinger/SurfaceFlinger.cpp

+16 −29

Original line number	Diff line number	Diff line
		@@ -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 */
		@@ -1834,26 +1834,24 @@ 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(h0.5f) + (1-co)(w0.5f);
		y =-si(w0.5f) + (1-co)(h0.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);
		}
		}

		mOrientation = orientation;
		mGlobalTransform = mDisplayTransform * orientationTransform;
		return NO_ERROR;

libs/surfaceflinger/Transform.cpp

+272 −118

Original line number	Diff line number	Diff line
		@@ -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);
		r.mType \|= rhs.mType;
		if (rhs.mType == IDENTITY)
		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 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] = v0B[0][0] + v1B[0][1] + v2*B[0][2];
		D[1][i] = v0B[1][0] + v1B[1][1] + v2*B[1][2];
		D[2][i] = v0B[2][0] + v1B[2][1] + v2*B[2][2];
		}
		r.mType \|= rhs.mType;

		// 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 - r00x - r01y));
		mTransform.set(SkMatrix::kMTransY, SkIntToScalar(y - r10x - r11y));
		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;
		}

		void Transform::transform(GLfixed* point, int x, int y) const
		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;
		}

		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 (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;
		} else if (b && c && a==0 && d==0) {
		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 = 0x80000000;
		flags = ROT_INVALID;
		}
		} else {
		flags = ROT_INVALID;
		}
		return flags;

		mType = flags << 8;
		if (flags & ROT_INVALID) {
		mType \|= UNKNOWN;
		} else {
		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 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]);
		}

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

libs/surfaceflinger/Transform.h

+62 −32

Original line number	Diff line number	Diff line
		@@ -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,47 +47,78 @@ 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
		};

		// query the transform
		bool transformed() const;
		int32_t getOrientation() 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(); }
		private:
		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]; }
		};

		inline Transform(bool) : mType(0xFF) { };
		enum { UNKNOWN_TYPE = 0x80000000 };

		private:
		uint8_t type() const;
		// 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);

		private:
		SkMatrix mTransform;
		void dump(const char* name) const;

		mat33 mMatrix;
		mutable uint32_t mType;
		};