summaryrefslogtreecommitdiff
path: root/services/surfaceflinger/Transform.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'services/surfaceflinger/Transform.cpp')
-rw-r--r--services/surfaceflinger/Transform.cpp387
1 files changed, 387 insertions, 0 deletions
diff --git a/services/surfaceflinger/Transform.cpp b/services/surfaceflinger/Transform.cpp
new file mode 100644
index 0000000..0467a14
--- /dev/null
+++ b/services/surfaceflinger/Transform.cpp
@@ -0,0 +1,387 @@
+/*
+ * 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.
+ */
+
+#include <math.h>
+
+#include <cutils/compiler.h>
+#include <utils/String8.h>
+#include <ui/Region.h>
+
+#include "Transform.h"
+
+// ---------------------------------------------------------------------------
+
+namespace android {
+
+// ---------------------------------------------------------------------------
+
+template <typename T>
+static inline T min(T a, T b) {
+ return a<b ? a : b;
+}
+template <typename T>
+static inline T min(T a, T b, T c) {
+ return min(a, min(b, c));
+}
+template <typename T>
+static inline T min(T a, T b, T c, T d) {
+ return min(a, b, min(c, d));
+}
+
+template <typename T>
+static inline T max(T a, T b) {
+ return a>b ? a : b;
+}
+template <typename T>
+static inline T max(T a, T b, T c) {
+ return max(a, max(b, c));
+}
+template <typename T>
+static inline T max(T a, T b, T c, T d) {
+ return max(a, b, max(c, d));
+}
+
+template <typename T>
+static inline
+void swap(T& a, T& b) {
+ T t(a);
+ a = b;
+ b = t;
+}
+
+// ---------------------------------------------------------------------------
+
+Transform::Transform() {
+ reset();
+}
+
+Transform::Transform(const Transform& other)
+ : mMatrix(other.mMatrix), mType(other.mType) {
+}
+
+Transform::Transform(uint32_t orientation) {
+ set(orientation, 0, 0);
+}
+
+Transform::~Transform() {
+}
+
+static const float EPSILON = 0.0f;
+
+bool Transform::isZero(float f) {
+ return fabs(f) <= EPSILON;
+}
+
+bool Transform::absIsOne(float f) {
+ return isZero(fabs(f) - 1.0f);
+}
+
+Transform Transform::operator * (const Transform& rhs) const
+{
+ if (CC_LIKELY(mType == IDENTITY))
+ return rhs;
+
+ Transform r(*this);
+ 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;
+
+ // TODO: we could recompute this value from r and rhs
+ r.mType &= 0xFF;
+ r.mType |= UNKNOWN_TYPE;
+ return r;
+}
+
+float const* Transform::operator [] (int i) const {
+ return mMatrix[i].v;
+}
+
+bool Transform::transformed() const {
+ return type() > TRANSLATE;
+}
+
+int Transform::tx() const {
+ return floorf(mMatrix[2][0] + 0.5f);
+}
+
+int Transform::ty() const {
+ return floorf(mMatrix[2][1] + 0.5f);
+}
+
+void Transform::reset() {
+ 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 tx, float ty)
+{
+ 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 a, float b, float c, float d)
+{
+ 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;
+}
+
+status_t Transform::set(uint32_t flags, float w, float h)
+{
+ if (flags & ROT_INVALID) {
+ // that's not allowed!
+ reset();
+ return BAD_VALUE;
+ }
+
+ Transform H, V, R;
+ if (flags & ROT_90) {
+ // w & h are inverted when rotating by 90 degrees
+ swap(w, h);
+ }
+
+ if (flags & FLIP_H) {
+ H.mType = (FLIP_H << 8) | SCALE;
+ H.mType |= isZero(w) ? IDENTITY : TRANSLATE;
+ mat33& M(H.mMatrix);
+ M[0][0] = -1;
+ M[2][0] = w;
+ }
+
+ if (flags & FLIP_V) {
+ V.mType = (FLIP_V << 8) | SCALE;
+ V.mType |= isZero(h) ? IDENTITY : TRANSLATE;
+ mat33& M(V.mMatrix);
+ M[1][1] = -1;
+ M[2][1] = h;
+ }
+
+ if (flags & ROT_90) {
+ const float original_w = h;
+ R.mType = (ROT_90 << 8) | ROTATE;
+ R.mType |= isZero(original_w) ? IDENTITY : TRANSLATE;
+ mat33& M(R.mMatrix);
+ M[0][0] = 0; M[1][0] =-1; M[2][0] = original_w;
+ M[0][1] = 1; M[1][1] = 0;
+ }
+
+ *this = (R*(H*V));
+ return NO_ERROR;
+}
+
+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(float* point, int x, int y) const
+{
+ const mat33& M(mMatrix);
+ vec2 v(x, y);
+ v = transform(v);
+ point[0] = v[0];
+ point[1] = v[1];
+}
+
+Rect Transform::makeBounds(int w, int h) const
+{
+ return transform( Rect(w, h) );
+}
+
+Rect Transform::transform(const Rect& bounds) const
+{
+ Rect r;
+ 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 (CC_UNLIKELY(transformed())) {
+ if (CC_LIKELY(preserveRects())) {
+ Region::const_iterator it = reg.begin();
+ Region::const_iterator const end = reg.end();
+ while (it != end) {
+ out.orSelf(transform(*it++));
+ }
+ } else {
+ out.set(transform(reg.bounds()));
+ }
+ } else {
+ out = reg.translate(tx(), ty());
+ }
+ return out;
+}
+
+uint32_t Transform::type() const
+{
+ 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 (a<0) flags |= FLIP_H;
+ if (d<0) flags |= FLIP_V;
+ if (!absIsOne(a) || !absIsOne(d)) {
+ scale = true;
+ }
+ } else if (isZero(a) && isZero(d)) {
+ flags |= ROT_90;
+ if (b>0) flags |= FLIP_V;
+ if (c<0) flags |= FLIP_H;
+ if (!absIsOne(b) || !absIsOne(c)) {
+ scale = true;
+ }
+ } else {
+ flags = ROT_INVALID;
+ }
+
+ 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 (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 ");
+ } else {
+ if (orient&ROT_90) {
+ flags.append("ROT_90 ");
+ } else {
+ flags.append("ROT_0 ");
+ }
+ if (orient&FLIP_V)
+ flags.append("FLIP_V ");
+ if (orient&FLIP_H)
+ flags.append("FLIP_H ");
+ }
+
+ if (!(mType&(SCALE|ROTATE|TRANSLATE)))
+ type.append("IDENTITY ");
+ if (mType&SCALE)
+ type.append("SCALE ");
+ if (mType&ROTATE)
+ type.append("ROTATE ");
+ if (mType&TRANSLATE)
+ type.append("TRANSLATE ");
+
+ LOGD("%s 0x%08x (%s, %s)", name, mType, flags.string(), type.string());
+ LOGD("%.4f %.4f %.4f", m[0][0], m[1][0], m[2][0]);
+ LOGD("%.4f %.4f %.4f", m[0][1], m[1][1], m[2][1]);
+ LOGD("%.4f %.4f %.4f", m[0][2], m[1][2], m[2][2]);
+}
+
+// ---------------------------------------------------------------------------
+
+}; // namespace android