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 "Transform.h"
24 #include "clz.h"
25
26 // ---------------------------------------------------------------------------
27
28 namespace android {
29
30 // ---------------------------------------------------------------------------
31
Transform()32 Transform::Transform() {
33 reset();
34 }
35
Transform(const Transform & other)36 Transform::Transform(const Transform& other)
37 : mMatrix(other.mMatrix), mType(other.mType) {
38 }
39
Transform(uint32_t orientation)40 Transform::Transform(uint32_t orientation) {
41 set(orientation, 0, 0);
42 }
43
~Transform()44 Transform::~Transform() {
45 }
46
47 static const float EPSILON = 0.0f;
48
isZero(float f)49 bool Transform::isZero(float f) {
50 return fabs(f) <= EPSILON;
51 }
52
absIsOne(float f)53 bool Transform::absIsOne(float f) {
54 return isZero(fabs(f) - 1.0f);
55 }
56
operator *(const Transform & rhs) const57 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
operator [](size_t i) const86 const vec3& Transform::operator [] (size_t i) const {
87 return mMatrix[i];
88 }
89
tx() const90 float Transform::tx() const {
91 return mMatrix[2][0];
92 }
93
ty() const94 float Transform::ty() const {
95 return mMatrix[2][1];
96 }
97
reset()98 void Transform::reset() {
99 mType = IDENTITY;
100 for(int i=0 ; i<3 ; i++) {
101 vec3& v(mMatrix[i]);
102 for (int j=0 ; j<3 ; j++)
103 v[j] = ((i==j) ? 1.0f : 0.0f);
104 }
105 }
106
set(float tx,float ty)107 void Transform::set(float tx, float ty)
108 {
109 mMatrix[2][0] = tx;
110 mMatrix[2][1] = ty;
111 mMatrix[2][2] = 1.0f;
112
113 if (isZero(tx) && isZero(ty)) {
114 mType &= ~TRANSLATE;
115 } else {
116 mType |= TRANSLATE;
117 }
118 }
119
set(float a,float b,float c,float d)120 void Transform::set(float a, float b, float c, float d)
121 {
122 mat33& M(mMatrix);
123 M[0][0] = a; M[1][0] = b;
124 M[0][1] = c; M[1][1] = d;
125 M[0][2] = 0; M[1][2] = 0;
126 mType = UNKNOWN_TYPE;
127 }
128
set(uint32_t flags,float w,float h)129 status_t Transform::set(uint32_t flags, float w, float h)
130 {
131 if (flags & ROT_INVALID) {
132 // that's not allowed!
133 reset();
134 return BAD_VALUE;
135 }
136
137 Transform H, V, R;
138 if (flags & ROT_90) {
139 // w & h are inverted when rotating by 90 degrees
140 swap(w, h);
141 }
142
143 if (flags & FLIP_H) {
144 H.mType = (FLIP_H << 8) | SCALE;
145 H.mType |= isZero(w) ? IDENTITY : TRANSLATE;
146 mat33& M(H.mMatrix);
147 M[0][0] = -1;
148 M[2][0] = w;
149 }
150
151 if (flags & FLIP_V) {
152 V.mType = (FLIP_V << 8) | SCALE;
153 V.mType |= isZero(h) ? IDENTITY : TRANSLATE;
154 mat33& M(V.mMatrix);
155 M[1][1] = -1;
156 M[2][1] = h;
157 }
158
159 if (flags & ROT_90) {
160 const float original_w = h;
161 R.mType = (ROT_90 << 8) | ROTATE;
162 R.mType |= isZero(original_w) ? IDENTITY : TRANSLATE;
163 mat33& M(R.mMatrix);
164 M[0][0] = 0; M[1][0] =-1; M[2][0] = original_w;
165 M[0][1] = 1; M[1][1] = 0;
166 }
167
168 *this = (R*(H*V));
169 return NO_ERROR;
170 }
171
transform(const vec2 & v) const172 vec2 Transform::transform(const vec2& v) const {
173 vec2 r;
174 const mat33& M(mMatrix);
175 r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0];
176 r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1];
177 return r;
178 }
179
transform(const vec3 & v) const180 vec3 Transform::transform(const vec3& v) const {
181 vec3 r;
182 const mat33& M(mMatrix);
183 r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0]*v[2];
184 r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1]*v[2];
185 r[2] = M[0][2]*v[0] + M[1][2]*v[1] + M[2][2]*v[2];
186 return r;
187 }
188
transform(int x,int y) const189 vec2 Transform::transform(int x, int y) const
190 {
191 return transform(vec2(x,y));
192 }
193
makeBounds(int w,int h) const194 Rect Transform::makeBounds(int w, int h) const
195 {
196 return transform( Rect(w, h) );
197 }
198
transform(const Rect & bounds,bool roundOutwards) const199 Rect Transform::transform(const Rect& bounds, bool roundOutwards) const
200 {
201 Rect r;
202 vec2 lt( bounds.left, bounds.top );
203 vec2 rt( bounds.right, bounds.top );
204 vec2 lb( bounds.left, bounds.bottom );
205 vec2 rb( bounds.right, bounds.bottom );
206
207 lt = transform(lt);
208 rt = transform(rt);
209 lb = transform(lb);
210 rb = transform(rb);
211
212 if (roundOutwards) {
213 r.left = floorf(min(lt[0], rt[0], lb[0], rb[0]));
214 r.top = floorf(min(lt[1], rt[1], lb[1], rb[1]));
215 r.right = ceilf(max(lt[0], rt[0], lb[0], rb[0]));
216 r.bottom = ceilf(max(lt[1], rt[1], lb[1], rb[1]));
217 } else {
218 r.left = floorf(min(lt[0], rt[0], lb[0], rb[0]) + 0.5f);
219 r.top = floorf(min(lt[1], rt[1], lb[1], rb[1]) + 0.5f);
220 r.right = floorf(max(lt[0], rt[0], lb[0], rb[0]) + 0.5f);
221 r.bottom = floorf(max(lt[1], rt[1], lb[1], rb[1]) + 0.5f);
222 }
223
224 return r;
225 }
226
transform(const FloatRect & bounds) const227 FloatRect Transform::transform(const FloatRect& bounds) const
228 {
229 vec2 lt(bounds.left, bounds.top);
230 vec2 rt(bounds.right, bounds.top);
231 vec2 lb(bounds.left, bounds.bottom);
232 vec2 rb(bounds.right, bounds.bottom);
233
234 lt = transform(lt);
235 rt = transform(rt);
236 lb = transform(lb);
237 rb = transform(rb);
238
239 FloatRect r;
240 r.left = min(lt[0], rt[0], lb[0], rb[0]);
241 r.top = min(lt[1], rt[1], lb[1], rb[1]);
242 r.right = max(lt[0], rt[0], lb[0], rb[0]);
243 r.bottom = max(lt[1], rt[1], lb[1], rb[1]);
244
245 return r;
246 }
247
transform(const Region & reg) const248 Region Transform::transform(const Region& reg) const
249 {
250 Region out;
251 if (CC_UNLIKELY(type() > TRANSLATE)) {
252 if (CC_LIKELY(preserveRects())) {
253 Region::const_iterator it = reg.begin();
254 Region::const_iterator const end = reg.end();
255 while (it != end) {
256 out.orSelf(transform(*it++));
257 }
258 } else {
259 out.set(transform(reg.bounds()));
260 }
261 } else {
262 int xpos = floorf(tx() + 0.5f);
263 int ypos = floorf(ty() + 0.5f);
264 out = reg.translate(xpos, ypos);
265 }
266 return out;
267 }
268
type() const269 uint32_t Transform::type() const
270 {
271 if (mType & UNKNOWN_TYPE) {
272 // recompute what this transform is
273
274 const mat33& M(mMatrix);
275 const float a = M[0][0];
276 const float b = M[1][0];
277 const float c = M[0][1];
278 const float d = M[1][1];
279 const float x = M[2][0];
280 const float y = M[2][1];
281
282 bool scale = false;
283 uint32_t flags = ROT_0;
284 if (isZero(b) && isZero(c)) {
285 if (a<0) flags |= FLIP_H;
286 if (d<0) flags |= FLIP_V;
287 if (!absIsOne(a) || !absIsOne(d)) {
288 scale = true;
289 }
290 } else if (isZero(a) && isZero(d)) {
291 flags |= ROT_90;
292 if (b>0) flags |= FLIP_V;
293 if (c<0) flags |= FLIP_H;
294 if (!absIsOne(b) || !absIsOne(c)) {
295 scale = true;
296 }
297 } else {
298 // there is a skew component and/or a non 90 degrees rotation
299 flags = ROT_INVALID;
300 }
301
302 mType = flags << 8;
303 if (flags & ROT_INVALID) {
304 mType |= UNKNOWN;
305 } else {
306 if ((flags & ROT_90) || ((flags & ROT_180) == ROT_180))
307 mType |= ROTATE;
308 if (flags & FLIP_H)
309 mType ^= SCALE;
310 if (flags & FLIP_V)
311 mType ^= SCALE;
312 if (scale)
313 mType |= SCALE;
314 }
315
316 if (!isZero(x) || !isZero(y))
317 mType |= TRANSLATE;
318 }
319 return mType;
320 }
321
inverse() const322 Transform Transform::inverse() const {
323 // our 3x3 matrix is always of the form of a 2x2 transformation
324 // followed by a translation: T*M, therefore:
325 // (T*M)^-1 = M^-1 * T^-1
326 Transform result;
327 if (mType <= TRANSLATE) {
328 // 1 0 0
329 // 0 1 0
330 // x y 1
331 result = *this;
332 result.mMatrix[2][0] = -result.mMatrix[2][0];
333 result.mMatrix[2][1] = -result.mMatrix[2][1];
334 } else {
335 // a c 0
336 // b d 0
337 // x y 1
338 const mat33& M(mMatrix);
339 const float a = M[0][0];
340 const float b = M[1][0];
341 const float c = M[0][1];
342 const float d = M[1][1];
343 const float x = M[2][0];
344 const float y = M[2][1];
345
346 const float idet = 1.0 / (a*d - b*c);
347 result.mMatrix[0][0] = d*idet;
348 result.mMatrix[0][1] = -c*idet;
349 result.mMatrix[1][0] = -b*idet;
350 result.mMatrix[1][1] = a*idet;
351 result.mType = mType;
352
353 vec2 T(-x, -y);
354 T = result.transform(T);
355 result.mMatrix[2][0] = T[0];
356 result.mMatrix[2][1] = T[1];
357 }
358 return result;
359 }
360
getType() const361 uint32_t Transform::getType() const {
362 return type() & 0xFF;
363 }
364
getOrientation() const365 uint32_t Transform::getOrientation() const
366 {
367 return (type() >> 8) & 0xFF;
368 }
369
preserveRects() const370 bool Transform::preserveRects() const
371 {
372 return (getOrientation() & ROT_INVALID) ? false : true;
373 }
374
dump(const char * name) const375 void Transform::dump(const char* name) const
376 {
377 type(); // updates the type
378
379 String8 flags, type;
380 const mat33& m(mMatrix);
381 uint32_t orient = mType >> 8;
382
383 if (orient&ROT_INVALID) {
384 flags.append("ROT_INVALID ");
385 } else {
386 if (orient&ROT_90) {
387 flags.append("ROT_90 ");
388 } else {
389 flags.append("ROT_0 ");
390 }
391 if (orient&FLIP_V)
392 flags.append("FLIP_V ");
393 if (orient&FLIP_H)
394 flags.append("FLIP_H ");
395 }
396
397 if (!(mType&(SCALE|ROTATE|TRANSLATE)))
398 type.append("IDENTITY ");
399 if (mType&SCALE)
400 type.append("SCALE ");
401 if (mType&ROTATE)
402 type.append("ROTATE ");
403 if (mType&TRANSLATE)
404 type.append("TRANSLATE ");
405
406 ALOGD("%s 0x%08x (%s, %s)", name, mType, flags.string(), type.string());
407 ALOGD("%.4f %.4f %.4f", m[0][0], m[1][0], m[2][0]);
408 ALOGD("%.4f %.4f %.4f", m[0][1], m[1][1], m[2][1]);
409 ALOGD("%.4f %.4f %.4f", m[0][2], m[1][2], m[2][2]);
410 }
411
fromRotation(ISurfaceComposer::Rotation rotation)412 Transform::orientation_flags Transform::fromRotation(ISurfaceComposer::Rotation rotation) {
413 // Convert to surfaceflinger's internal rotation type.
414 switch (rotation) {
415 case ISurfaceComposer::eRotateNone:
416 return Transform::ROT_0;
417 case ISurfaceComposer::eRotate90:
418 return Transform::ROT_90;
419 case ISurfaceComposer::eRotate180:
420 return Transform::ROT_180;
421 case ISurfaceComposer::eRotate270:
422 return Transform::ROT_270;
423 default:
424 ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
425 return Transform::ROT_0;
426 }
427 }
428
429 // ---------------------------------------------------------------------------
430
431 }; // namespace android
432