services/surfaceflinger/Transform.cpp

   1 /*
   2  * Copyright (C) 2007 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <math.h>
  18
  19 #include <cutils/compiler.h>
  20 #include <utils/String8.h>
  21 #include <ui/Region.h>
  22
  23 #include "clz.h"
  24 #include "Transform.h"
  25
  26 // ---------------------------------------------------------------------------
  27
  28 namespace android {
  29
  30 // ---------------------------------------------------------------------------
  31
  32 Transform::Transform() {
  33     reset();
  34 }
  35
  36 Transform::Transform(const Transform&  other)
  37     : mMatrix(other.mMatrix), mType(other.mType) {
  38 }
  39
  40 Transform::Transform(uint32_t orientation) {
  41     set(orientation, 0, 0);
  42 }
  43
  44 Transform::~Transform() {
  45 }
  46
  47 static const float EPSILON = 0.0f;
  48
  49 bool Transform::isZero(float f) {
  50     return fabs(f) <= EPSILON;
  51 }
  52
  53 bool Transform::absIsOne(float f) {
  54     return isZero(fabs(f) - 1.0f);
  55 }
  56
  57 Transform Transform::operator * (const Transform& rhs) const
  58 {
  59     if (CC_LIKELY(mType == IDENTITY))
  60         return rhs;
  61
  62     Transform r(*this);
  63     if (rhs.mType == IDENTITY)
  64         return r;
  65
  66     // TODO: we could use mType to optimize the matrix multiply
  67     const mat33& A(mMatrix);
  68     const mat33& B(rhs.mMatrix);
  69           mat33& D(r.mMatrix);
  70     for (int i=0 ; i<3 ; i++) {
  71         const float v0 = A[0][i];
  72         const float v1 = A[1][i];
  73         const float v2 = A[2][i];
  74         D[0][i] = v0*B[0][0] + v1*B[0][1] + v2*B[0][2];
  75         D[1][i] = v0*B[1][0] + v1*B[1][1] + v2*B[1][2];
  76         D[2][i] = v0*B[2][0] + v1*B[2][1] + v2*B[2][2];
  77     }
  78     r.mType |= rhs.mType;
  79
  80     // TODO: we could recompute this value from r and rhs
  81     r.mType &= 0xFF;
  82     r.mType |= UNKNOWN_TYPE;
  83     return r;
  84 }
  85
  86 const vec3& Transform::operator [] (size_t i) const {
  87     return mMatrix[i];
  88 }
  89
  90 bool Transform::transformed() const {
  91     return type() > TRANSLATE;
  92 }
  93
  94 float Transform::tx() const {
  95     return mMatrix[2][0];
  96 }
  97
  98 float Transform::ty() const {
  99     return mMatrix[2][1];
 100 }
 101
 102 void Transform::reset() {
 103     mType = IDENTITY;
 104     for(int i=0 ; i<3 ; i++) {
 105         vec3& v(mMatrix[i]);
 106         for (int j=0 ; j<3 ; j++)
 107             v[j] = ((i==j) ? 1.0f : 0.0f);
 108     }
 109 }
 110
 111 void Transform::set(float tx, float ty)
 112 {
 113     mMatrix[2][0] = tx;
 114     mMatrix[2][1] = ty;
 115     mMatrix[2][2] = 1.0f;
 116
 117     if (isZero(tx) && isZero(ty)) {
 118         mType &= ~TRANSLATE;
 119     } else {
 120         mType |= TRANSLATE;
 121     }
 122 }
 123
 124 void Transform::set(float a, float b, float c, float d)
 125 {
 126     mat33& M(mMatrix);
 127     M[0][0] = a;    M[1][0] = b;
 128     M[0][1] = c;    M[1][1] = d;
 129     M[0][2] = 0;    M[1][2] = 0;
 130     mType = UNKNOWN_TYPE;
 131 }
 132
 133 status_t Transform::set(uint32_t flags, float w, float h)
 134 {
 135     if (flags & ROT_INVALID) {
 136         // that's not allowed!
 137         reset();
 138         return BAD_VALUE;
 139     }
 140
 141     Transform H, V, R;
 142     if (flags & ROT_90) {
 143         // w & h are inverted when rotating by 90 degrees
 144         swap(w, h);
 145     }
 146
 147     if (flags & FLIP_H) {
 148         H.mType = (FLIP_H << 8) | SCALE;
 149         H.mType |= isZero(w) ? IDENTITY : TRANSLATE;
 150         mat33& M(H.mMatrix);
 151         M[0][0] = -1;
 152         M[2][0] = w;
 153     }
 154
 155     if (flags & FLIP_V) {
 156         V.mType = (FLIP_V << 8) | SCALE;
 157         V.mType |= isZero(h) ? IDENTITY : TRANSLATE;
 158         mat33& M(V.mMatrix);
 159         M[1][1] = -1;
 160         M[2][1] = h;
 161     }
 162
 163     if (flags & ROT_90) {
 164         const float original_w = h;
 165         R.mType = (ROT_90 << 8) | ROTATE;
 166         R.mType |= isZero(original_w) ? IDENTITY : TRANSLATE;
 167         mat33& M(R.mMatrix);
 168         M[0][0] = 0;    M[1][0] =-1;    M[2][0] = original_w;
 169         M[0][1] = 1;    M[1][1] = 0;
 170     }
 171
 172     *this = (R*(H*V));
 173     return NO_ERROR;
 174 }
 175
 176 vec2 Transform::transform(const vec2& v) const {
 177     vec2 r;
 178     const mat33& M(mMatrix);
 179     r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0];
 180     r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1];
 181     return r;
 182 }
 183
 184 vec3 Transform::transform(const vec3& v) const {
 185     vec3 r;
 186     const mat33& M(mMatrix);
 187     r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0]*v[2];
 188     r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1]*v[2];
 189     r[2] = M[0][2]*v[0] + M[1][2]*v[1] + M[2][2]*v[2];
 190     return r;
 191 }
 192
 193 vec2 Transform::transform(int x, int y) const
 194 {
 195     return transform(vec2(x,y));
 196 }
 197
 198 Rect Transform::makeBounds(int w, int h) const
 199 {
 200     return transform( Rect(w, h) );
 201 }
 202
 203 Rect Transform::transform(const Rect& bounds) const
 204 {
 205     Rect r;
 206     vec2 lt( bounds.left,  bounds.top    );
 207     vec2 rt( bounds.right, bounds.top    );
 208     vec2 lb( bounds.left,  bounds.bottom );
 209     vec2 rb( bounds.right, bounds.bottom );
 210
 211     lt = transform(lt);
 212     rt = transform(rt);
 213     lb = transform(lb);
 214     rb = transform(rb);
 215
 216     r.left   = floorf(min(lt[0], rt[0], lb[0], rb[0]) + 0.5f);
 217     r.top    = floorf(min(lt[1], rt[1], lb[1], rb[1]) + 0.5f);
 218     r.right  = floorf(max(lt[0], rt[0], lb[0], rb[0]) + 0.5f);
 219     r.bottom = floorf(max(lt[1], rt[1], lb[1], rb[1]) + 0.5f);
 220
 221     return r;
 222 }
 223
 224 Region Transform::transform(const Region& reg) const
 225 {
 226     Region out;
 227     if (CC_UNLIKELY(transformed())) {
 228         if (CC_LIKELY(preserveRects())) {
 229             Region::const_iterator it = reg.begin();
 230             Region::const_iterator const end = reg.end();
 231             while (it != end) {
 232                 out.orSelf(transform(*it++));
 233             }
 234         } else {
 235             out.set(transform(reg.bounds()));
 236         }
 237     } else {
 238         int xpos = floorf(tx() + 0.5f);
 239         int ypos = floorf(ty() + 0.5f);
 240         out = reg.translate(xpos, ypos);
 241     }
 242     return out;
 243 }
 244
 245 uint32_t Transform::type() const
 246 {
 247     if (mType & UNKNOWN_TYPE) {
 248         // recompute what this transform is
 249
 250         const mat33& M(mMatrix);
 251         const float a = M[0][0];
 252         const float b = M[1][0];
 253         const float c = M[0][1];
 254         const float d = M[1][1];
 255         const float x = M[2][0];
 256         const float y = M[2][1];
 257
 258         bool scale = false;
 259         uint32_t flags = ROT_0;
 260         if (isZero(b) && isZero(c)) {
 261             if (a<0)    flags |= FLIP_H;
 262             if (d<0)    flags |= FLIP_V;
 263             if (!absIsOne(a) || !absIsOne(d)) {
 264                 scale = true;
 265             }
 266         } else if (isZero(a) && isZero(d)) {
 267             flags |= ROT_90;
 268             if (b>0)    flags |= FLIP_V;
 269             if (c<0)    flags |= FLIP_H;
 270             if (!absIsOne(b) || !absIsOne(c)) {
 271                 scale = true;
 272             }
 273         } else {
 274             // there is a skew component and/or a non 90 degrees rotation
 275             flags = ROT_INVALID;
 276         }
 277
 278         mType = flags << 8;
 279         if (flags & ROT_INVALID) {
 280             mType |= UNKNOWN;
 281         } else {
 282             if ((flags & ROT_90) || ((flags & ROT_180) == ROT_180))
 283                 mType |= ROTATE;
 284             if (flags & FLIP_H)
 285                 mType ^= SCALE;
 286             if (flags & FLIP_V)
 287                 mType ^= SCALE;
 288             if (scale)
 289                 mType |= SCALE;
 290         }
 291
 292         if (!isZero(x) || !isZero(y))
 293             mType |= TRANSLATE;
 294     }
 295     return mType;
 296 }
 297
 298 Transform Transform::inverse() const {
 299     // our 3x3 matrix is always of the form of a 2x2 transformation
 300     // followed by a translation: T*M, therefore:
 301     // (T*M)^-1 = M^-1 * T^-1
 302     Transform result;
 303     if (mType <= TRANSLATE) {
 304         // 1 0 x
 305         // 0 1 y
 306         // 0 0 1
 307         result = *this;
 308         result.mMatrix[2][0] = -result.mMatrix[2][0];
 309         result.mMatrix[2][1] = -result.mMatrix[2][1];
 310     } else {
 311         // a c x
 312         // b d y
 313         // 0 0 1
 314         const mat33& M(mMatrix);
 315         const float a = M[0][0];
 316         const float b = M[1][0];
 317         const float c = M[0][1];
 318         const float d = M[1][1];
 319         const float x = M[2][0];
 320         const float y = M[2][1];
 321
 322         Transform R, T;
 323         const float idet = 1.0 / (a*d - b*c);
 324         R.mMatrix[0][0] =  d*idet;    R.mMatrix[0][1] = -c*idet;
 325         R.mMatrix[1][0] = -b*idet;    R.mMatrix[1][1] =  a*idet;
 326         R.mType = mType &= ~TRANSLATE;
 327
 328         T.mMatrix[2][0] = -x;
 329         T.mMatrix[2][1] = -y;
 330         T.mType = TRANSLATE;
 331         result =  R * T;
 332     }
 333     return result;
 334 }
 335
 336 uint32_t Transform::getType() const {
 337     return type() & 0xFF;
 338 }
 339
 340 uint32_t Transform::getOrientation() const
 341 {
 342     return (type() >> 8) & 0xFF;
 343 }
 344
 345 bool Transform::preserveRects() const
 346 {
 347     return (getOrientation() & ROT_INVALID) ? false : true;
 348 }
 349
 350 void Transform::dump(const char* name) const
 351 {
 352     type(); // updates the type
 353
 354     String8 flags, type;
 355     const mat33& m(mMatrix);
 356     uint32_t orient = mType >> 8;
 357
 358     if (orient&ROT_INVALID) {
 359         flags.append("ROT_INVALID ");
 360     } else {
 361         if (orient&ROT_90) {
 362             flags.append("ROT_90 ");
 363         } else {
 364             flags.append("ROT_0 ");
 365         }
 366         if (orient&FLIP_V)
 367             flags.append("FLIP_V ");
 368         if (orient&FLIP_H)
 369             flags.append("FLIP_H ");
 370     }
 371
 372     if (!(mType&(SCALE|ROTATE|TRANSLATE)))
 373         type.append("IDENTITY ");
 374     if (mType&SCALE)
 375         type.append("SCALE ");
 376     if (mType&ROTATE)
 377         type.append("ROTATE ");
 378     if (mType&TRANSLATE)
 379         type.append("TRANSLATE ");
 380
 381     ALOGD("%s 0x%08x (%s, %s)", name, mType, flags.string(), type.string());
 382     ALOGD("%.4f  %.4f  %.4f", m[0][0], m[1][0], m[2][0]);
 383     ALOGD("%.4f  %.4f  %.4f", m[0][1], m[1][1], m[2][1]);
 384     ALOGD("%.4f  %.4f  %.4f", m[0][2], m[1][2], m[2][2]);
 385 }
 386
 387 // ---------------------------------------------------------------------------
 388
 389 }; // namespace android