1/* libs/android_runtime/android/graphics/Matrix.cpp
2**
3** Copyright 2006, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#include "GraphicsJNI.h"
19#include "Matrix.h"
20#include "SkMatrix.h"
21#include "core_jni_helpers.h"
22
23#include <Caches.h>
24#include <jni.h>
25
26namespace android {
27
28class SkMatrixGlue {
29public:
30
31    static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) {
32        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
33        delete obj;
34    }
35
36    static jlong create(JNIEnv* env, jobject clazz, jlong srcHandle) {
37        const SkMatrix* src = reinterpret_cast<SkMatrix*>(srcHandle);
38        SkMatrix* obj = new SkMatrix();
39        if (src)
40            *obj = *src;
41        else
42            obj->reset();
43        return reinterpret_cast<jlong>(obj);
44    }
45
46    static jboolean isIdentity(JNIEnv* env, jobject clazz, jlong objHandle) {
47        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
48        return obj->isIdentity() ? JNI_TRUE : JNI_FALSE;
49    }
50
51    static jboolean isAffine(JNIEnv* env, jobject clazz, jlong objHandle) {
52        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
53        return obj->asAffine(NULL) ? JNI_TRUE : JNI_FALSE;
54    }
55
56    static jboolean rectStaysRect(JNIEnv* env, jobject clazz, jlong objHandle) {
57        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
58        return obj->rectStaysRect() ? JNI_TRUE : JNI_FALSE;
59    }
60
61    static void reset(JNIEnv* env, jobject clazz, jlong objHandle) {
62        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
63        obj->reset();
64    }
65     static void set(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) {
66        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
67        SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle);
68        *obj = *other;
69    }
70     static void setTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
71        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
72        obj->setTranslate(dx, dy);
73    }
74     static void setScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) {
75        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
76        obj->setScale(sx, sy, px, py);
77    }
78     static void setScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) {
79        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
80        obj->setScale(sx, sy);
81    }
82     static void setRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) {
83        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
84        obj->setRotate(degrees, px, py);
85    }
86     static void setRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) {
87        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
88        obj->setRotate(degrees);
89    }
90     static void setSinCos__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) {
91        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
92        obj->setSinCos(sinValue, cosValue, px, py);
93    }
94     static void setSinCos__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue) {
95        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
96        obj->setSinCos(sinValue, cosValue);
97    }
98     static void setSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) {
99        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
100        obj->setSkew(kx, ky, px, py);
101    }
102     static void setSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) {
103        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
104        obj->setSkew(kx, ky);
105    }
106     static void setConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong aHandle, jlong bHandle) {
107        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
108        SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle);
109        SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle);
110        obj->setConcat(*a, *b);
111    }
112
113    static void preTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
114        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
115        obj->preTranslate(dx, dy);
116    }
117
118    static void preScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) {
119        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
120        obj->preScale(sx, sy, px, py);
121    }
122
123    static void preScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) {
124        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
125        obj->preScale(sx, sy);
126    }
127
128    static void preRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) {
129        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
130        obj->preRotate(degrees, px, py);
131    }
132
133    static void preRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) {
134        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
135        obj->preRotate(degrees);
136    }
137
138    static void preSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) {
139        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
140        obj->preSkew(kx, ky, px, py);
141    }
142
143    static void preSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) {
144        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
145        obj->preSkew(kx, ky);
146    }
147
148    static void preConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) {
149        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
150        SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle);
151        obj->preConcat(*other);
152    }
153
154    static void postTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
155        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
156        obj->postTranslate(dx, dy);
157    }
158
159    static void postScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) {
160        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
161        obj->postScale(sx, sy, px, py);
162    }
163
164    static void postScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) {
165        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
166        obj->postScale(sx, sy);
167    }
168
169    static void postRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) {
170        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
171        obj->postRotate(degrees, px, py);
172    }
173
174    static void postRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) {
175        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
176        obj->postRotate(degrees);
177    }
178
179    static void postSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) {
180        SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
181        obj->postSkew(kx, ky, px, py);
182    }
183
184    static void postSkew__FF(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat kx, jfloat ky) {
185        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
186        matrix->postSkew(kx, ky);
187    }
188
189    static void postConcat(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong otherHandle) {
190        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
191        SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle);
192        matrix->postConcat(*other);
193    }
194
195    static jboolean setRectToRect(JNIEnv* env, jobject clazz, jlong matrixHandle, jobject src, jobject dst, jint stfHandle) {
196        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
197        SkMatrix::ScaleToFit stf = static_cast<SkMatrix::ScaleToFit>(stfHandle);
198        SkRect src_;
199        GraphicsJNI::jrectf_to_rect(env, src, &src_);
200        SkRect dst_;
201        GraphicsJNI::jrectf_to_rect(env, dst, &dst_);
202        return matrix->setRectToRect(src_, dst_, stf) ? JNI_TRUE : JNI_FALSE;
203    }
204
205    static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, jlong matrixHandle,
206                                  jfloatArray jsrc, jint srcIndex,
207                                  jfloatArray jdst, jint dstIndex, jint ptCount) {
208        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
209        SkASSERT(srcIndex >= 0);
210        SkASSERT(dstIndex >= 0);
211        SkASSERT((unsigned)ptCount <= 4);
212
213        AutoJavaFloatArray autoSrc(env, jsrc, srcIndex + (ptCount << 1), kRO_JNIAccess);
214        AutoJavaFloatArray autoDst(env, jdst, dstIndex + (ptCount << 1), kRW_JNIAccess);
215        float* src = autoSrc.ptr() + srcIndex;
216        float* dst = autoDst.ptr() + dstIndex;
217        bool result;
218
219#ifdef SK_SCALAR_IS_FLOAT
220        result = matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst,
221                                     ptCount);
222#else
223        SkASSERT(false);
224#endif
225        return result ? JNI_TRUE : JNI_FALSE;
226    }
227
228    static jboolean invert(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong inverseHandle) {
229        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
230        SkMatrix* inverse = reinterpret_cast<SkMatrix*>(inverseHandle);
231        return matrix->invert(inverse);
232    }
233
234    static void mapPoints(JNIEnv* env, jobject clazz, jlong matrixHandle,
235                              jfloatArray dst, jint dstIndex,
236                              jfloatArray src, jint srcIndex,
237                              jint ptCount, jboolean isPts) {
238        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
239        SkASSERT(ptCount >= 0);
240        AutoJavaFloatArray autoSrc(env, src, srcIndex + (ptCount << 1), kRO_JNIAccess);
241        AutoJavaFloatArray autoDst(env, dst, dstIndex + (ptCount << 1), kRW_JNIAccess);
242        float* srcArray = autoSrc.ptr() + srcIndex;
243        float* dstArray = autoDst.ptr() + dstIndex;
244#ifdef SK_SCALAR_IS_FLOAT
245        if (isPts)
246            matrix->mapPoints((SkPoint*)dstArray, (const SkPoint*)srcArray,
247                              ptCount);
248        else
249            matrix->mapVectors((SkVector*)dstArray, (const SkVector*)srcArray,
250                               ptCount);
251#else
252        SkASSERT(false);
253#endif
254    }
255
256    static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, jlong matrixHandle, jobjectArray dst, jobject src) {
257        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
258        SkRect dst_, src_;
259        GraphicsJNI::jrectf_to_rect(env, src, &src_);
260        jboolean rectStaysRect = matrix->mapRect(&dst_, src_);
261        GraphicsJNI::rect_to_jrectf(dst_, env, dst);
262        return rectStaysRect ? JNI_TRUE : JNI_FALSE;
263    }
264
265    static jfloat mapRadius(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat radius) {
266        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
267        float result;
268        result = SkScalarToFloat(matrix->mapRadius(radius));
269        return static_cast<jfloat>(result);
270    }
271    static void getValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) {
272        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
273        AutoJavaFloatArray autoValues(env, values, 9, kRW_JNIAccess);
274        float* dst = autoValues.ptr();
275#ifdef SK_SCALAR_IS_FLOAT
276        for (int i = 0; i < 9; i++) {
277            dst[i] = matrix->get(i);
278        }
279#else
280        SkASSERT(false);
281#endif
282    }
283
284    static void setValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) {
285        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
286        AutoJavaFloatArray autoValues(env, values, 9, kRO_JNIAccess);
287        const float* src = autoValues.ptr();
288
289#ifdef SK_SCALAR_IS_FLOAT
290        for (int i = 0; i < 9; i++) {
291            matrix->set(i, src[i]);
292        }
293#else
294        SkASSERT(false);
295#endif
296    }
297
298    static jboolean equals(JNIEnv* env, jobject clazz, jlong aHandle, jlong bHandle) {
299        const SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle);
300        const SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle);
301        return *a == *b;
302    }
303 };
304
305static const JNINativeMethod methods[] = {
306    {"finalizer", "(J)V", (void*) SkMatrixGlue::finalizer},
307    {"native_create","(J)J", (void*) SkMatrixGlue::create},
308
309    {"native_isIdentity","!(J)Z", (void*) SkMatrixGlue::isIdentity},
310    {"native_isAffine","!(J)Z", (void*) SkMatrixGlue::isAffine},
311    {"native_rectStaysRect","!(J)Z", (void*) SkMatrixGlue::rectStaysRect},
312    {"native_reset","!(J)V", (void*) SkMatrixGlue::reset},
313    {"native_set","!(JJ)V", (void*) SkMatrixGlue::set},
314    {"native_setTranslate","!(JFF)V", (void*) SkMatrixGlue::setTranslate},
315    {"native_setScale","!(JFFFF)V", (void*) SkMatrixGlue::setScale__FFFF},
316    {"native_setScale","!(JFF)V", (void*) SkMatrixGlue::setScale__FF},
317    {"native_setRotate","!(JFFF)V", (void*) SkMatrixGlue::setRotate__FFF},
318    {"native_setRotate","!(JF)V", (void*) SkMatrixGlue::setRotate__F},
319    {"native_setSinCos","!(JFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF},
320    {"native_setSinCos","!(JFF)V", (void*) SkMatrixGlue::setSinCos__FF},
321    {"native_setSkew","!(JFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF},
322    {"native_setSkew","!(JFF)V", (void*) SkMatrixGlue::setSkew__FF},
323    {"native_setConcat","!(JJJ)V", (void*) SkMatrixGlue::setConcat},
324    {"native_preTranslate","!(JFF)V", (void*) SkMatrixGlue::preTranslate},
325    {"native_preScale","!(JFFFF)V", (void*) SkMatrixGlue::preScale__FFFF},
326    {"native_preScale","!(JFF)V", (void*) SkMatrixGlue::preScale__FF},
327    {"native_preRotate","!(JFFF)V", (void*) SkMatrixGlue::preRotate__FFF},
328    {"native_preRotate","!(JF)V", (void*) SkMatrixGlue::preRotate__F},
329    {"native_preSkew","!(JFFFF)V", (void*) SkMatrixGlue::preSkew__FFFF},
330    {"native_preSkew","!(JFF)V", (void*) SkMatrixGlue::preSkew__FF},
331    {"native_preConcat","!(JJ)V", (void*) SkMatrixGlue::preConcat},
332    {"native_postTranslate","!(JFF)V", (void*) SkMatrixGlue::postTranslate},
333    {"native_postScale","!(JFFFF)V", (void*) SkMatrixGlue::postScale__FFFF},
334    {"native_postScale","!(JFF)V", (void*) SkMatrixGlue::postScale__FF},
335    {"native_postRotate","!(JFFF)V", (void*) SkMatrixGlue::postRotate__FFF},
336    {"native_postRotate","!(JF)V", (void*) SkMatrixGlue::postRotate__F},
337    {"native_postSkew","!(JFFFF)V", (void*) SkMatrixGlue::postSkew__FFFF},
338    {"native_postSkew","!(JFF)V", (void*) SkMatrixGlue::postSkew__FF},
339    {"native_postConcat","!(JJ)V", (void*) SkMatrixGlue::postConcat},
340    {"native_setRectToRect","!(JLandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect},
341    {"native_setPolyToPoly","!(J[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly},
342    {"native_invert","!(JJ)Z", (void*) SkMatrixGlue::invert},
343    {"native_mapPoints","!(J[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints},
344    {"native_mapRect","!(JLandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF},
345    {"native_mapRadius","!(JF)F", (void*) SkMatrixGlue::mapRadius},
346    {"native_getValues","!(J[F)V", (void*) SkMatrixGlue::getValues},
347    {"native_setValues","!(J[F)V", (void*) SkMatrixGlue::setValues},
348    {"native_equals", "!(JJ)Z", (void*) SkMatrixGlue::equals}
349};
350
351static jfieldID sNativeInstanceField;
352
353int register_android_graphics_Matrix(JNIEnv* env) {
354    int result = RegisterMethodsOrDie(env, "android/graphics/Matrix", methods, NELEM(methods));
355
356    jclass clazz = FindClassOrDie(env, "android/graphics/Matrix");
357    sNativeInstanceField = GetFieldIDOrDie(env, clazz, "native_instance", "J");
358
359    return result;
360}
361
362SkMatrix* android_graphics_Matrix_getSkMatrix(JNIEnv* env, jobject matrixObj) {
363    return reinterpret_cast<SkMatrix*>(env->GetLongField(matrixObj, sNativeInstanceField));
364}
365
366}
367