diff options
| -rw-r--r-- | core/jni/android/graphics/Matrix.cpp | 388 | ||||
| -rw-r--r-- | graphics/java/android/graphics/Matrix.java | 637 |
2 files changed, 541 insertions, 484 deletions
diff --git a/core/jni/android/graphics/Matrix.cpp b/core/jni/android/graphics/Matrix.cpp index b0f3bb4b965a..f8bb77a9650c 100644 --- a/core/jni/android/graphics/Matrix.cpp +++ b/core/jni/android/graphics/Matrix.cpp @@ -2,16 +2,16 @@ ** ** Copyright 2006, 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 +** 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 +** 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 +** 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. */ @@ -25,14 +25,25 @@ namespace android { +static_assert(sizeof(SkMatrix) == 40, "Unexpected sizeof(SkMatrix), " + "update size in Matrix.java#NATIVE_ALLOCATION_SIZE and here"); +static_assert(SK_SCALAR_IS_FLOAT, "SK_SCALAR_IS_FLOAT is false, " + "only float scalar is supported"); + class SkMatrixGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { + // ---------------- Regular JNI ----------------------------- + + static void finalizer(jlong objHandle) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); delete obj; } + static jlong getNativeFinalizer(JNIEnv* env, jobject clazz) { + return static_cast<jlong>(reinterpret_cast<uintptr_t>(&finalizer)); + } + static jlong create(JNIEnv* env, jobject clazz, jlong srcHandle) { const SkMatrix* src = reinterpret_cast<SkMatrix*>(srcHandle); SkMatrix* obj = new SkMatrix(); @@ -43,309 +54,332 @@ public: return reinterpret_cast<jlong>(obj); } - static jboolean isIdentity(JNIEnv* env, jobject clazz, jlong objHandle) { + // ---------------- @FastNative ----------------------------- + + static void mapPoints(JNIEnv* env, jobject clazz, jlong matrixHandle, + jfloatArray dst, jint dstIndex, jfloatArray src, jint srcIndex, + jint ptCount, jboolean isPts) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkASSERT(ptCount >= 0); + AutoJavaFloatArray autoSrc(env, src, srcIndex + (ptCount << 1), + kRO_JNIAccess); + AutoJavaFloatArray autoDst(env, dst, dstIndex + (ptCount << 1), + kRW_JNIAccess); + float* srcArray = autoSrc.ptr() + srcIndex; + float* dstArray = autoDst.ptr() + dstIndex; + if (isPts) + matrix->mapPoints((SkPoint*) dstArray, (const SkPoint*) srcArray, + ptCount); + else + matrix->mapVectors((SkVector*) dstArray, (const SkVector*) srcArray, + ptCount); + } + + static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, + jlong matrixHandle, jobjectArray dst, jobject src) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkRect dst_, src_; + GraphicsJNI::jrectf_to_rect(env, src, &src_); + jboolean rectStaysRect = matrix->mapRect(&dst_, src_); + GraphicsJNI::rect_to_jrectf(dst_, env, dst); + return rectStaysRect ? JNI_TRUE : JNI_FALSE; + } + + static jboolean setRectToRect(JNIEnv* env, jobject clazz, + jlong matrixHandle, jobject src, jobject dst, jint stfHandle) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkMatrix::ScaleToFit stf = static_cast<SkMatrix::ScaleToFit>(stfHandle); + SkRect src_; + GraphicsJNI::jrectf_to_rect(env, src, &src_); + SkRect dst_; + GraphicsJNI::jrectf_to_rect(env, dst, &dst_); + return matrix->setRectToRect(src_, dst_, stf) ? JNI_TRUE : JNI_FALSE; + } + + static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, + jlong matrixHandle, jfloatArray jsrc, jint srcIndex, + jfloatArray jdst, jint dstIndex, jint ptCount) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkASSERT(srcIndex >= 0); + SkASSERT(dstIndex >= 0); + SkASSERT((unsigned )ptCount <= 4); + + AutoJavaFloatArray autoSrc(env, jsrc, srcIndex + (ptCount << 1), + kRO_JNIAccess); + AutoJavaFloatArray autoDst(env, jdst, dstIndex + (ptCount << 1), + kRW_JNIAccess); + float* src = autoSrc.ptr() + srcIndex; + float* dst = autoDst.ptr() + dstIndex; + bool result; + + result = matrix->setPolyToPoly((const SkPoint*) src, + (const SkPoint*) dst, ptCount); + return result ? JNI_TRUE : JNI_FALSE; + } + + static void getValues(JNIEnv* env, jobject clazz, jlong matrixHandle, + jfloatArray values) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + AutoJavaFloatArray autoValues(env, values, 9, kRW_JNIAccess); + float* dst = autoValues.ptr(); + for (int i = 0; i < 9; i++) { + dst[i] = matrix->get(i); + } + } + + static void setValues(JNIEnv* env, jobject clazz, jlong matrixHandle, + jfloatArray values) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + AutoJavaFloatArray autoValues(env, values, 9, kRO_JNIAccess); + const float* src = autoValues.ptr(); + + for (int i = 0; i < 9; i++) { + matrix->set(i, src[i]); + } + } + + // ---------------- @CriticalNative ----------------------------- + + static jboolean isIdentity(jlong objHandle) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); return obj->isIdentity() ? JNI_TRUE : JNI_FALSE; } - static jboolean isAffine(JNIEnv* env, jobject clazz, jlong objHandle) { + static jboolean isAffine(jlong objHandle) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); return obj->asAffine(NULL) ? JNI_TRUE : JNI_FALSE; } - static jboolean rectStaysRect(JNIEnv* env, jobject clazz, jlong objHandle) { + static jboolean rectStaysRect(jlong objHandle) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); return obj->rectStaysRect() ? JNI_TRUE : JNI_FALSE; } - static void reset(JNIEnv* env, jobject clazz, jlong objHandle) { + static void reset(jlong objHandle) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->reset(); } - static void set(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) { + + static void set(jlong objHandle, jlong otherHandle) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); *obj = *other; } - static void setTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + + static void setTranslate(jlong objHandle, jfloat dx, jfloat dy) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->setTranslate(dx, dy); } - static void setScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { + + static void setScale__FFFF(jlong objHandle, jfloat sx, jfloat sy, jfloat px, + jfloat py) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->setScale(sx, sy, px, py); } - static void setScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { + + static void setScale__FF(jlong objHandle, jfloat sx, jfloat sy) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->setScale(sx, sy); } - static void setRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { + + static void setRotate__FFF(jlong objHandle, jfloat degrees, jfloat px, + jfloat py) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->setRotate(degrees, px, py); } - static void setRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { + + static void setRotate__F(jlong objHandle, jfloat degrees) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->setRotate(degrees); } - static void setSinCos__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) { + + static void setSinCos__FFFF(jlong objHandle, jfloat sinValue, + jfloat cosValue, jfloat px, jfloat py) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->setSinCos(sinValue, cosValue, px, py); } - static void setSinCos__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue) { + + static void setSinCos__FF(jlong objHandle, jfloat sinValue, + jfloat cosValue) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->setSinCos(sinValue, cosValue); } - static void setSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { + + static void setSkew__FFFF(jlong objHandle, jfloat kx, jfloat ky, jfloat px, + jfloat py) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->setSkew(kx, ky, px, py); } - static void setSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) { + + static void setSkew__FF(jlong objHandle, jfloat kx, jfloat ky) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->setSkew(kx, ky); } - static void setConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong aHandle, jlong bHandle) { + + static void setConcat(jlong objHandle, jlong aHandle, jlong bHandle) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle); SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle); obj->setConcat(*a, *b); } - static void preTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + static void preTranslate(jlong objHandle, jfloat dx, jfloat dy) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->preTranslate(dx, dy); } - static void preScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { + static void preScale__FFFF(jlong objHandle, jfloat sx, jfloat sy, jfloat px, + jfloat py) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->preScale(sx, sy, px, py); } - static void preScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { + static void preScale__FF(jlong objHandle, jfloat sx, jfloat sy) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->preScale(sx, sy); } - static void preRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { + static void preRotate__FFF(jlong objHandle, jfloat degrees, jfloat px, + jfloat py) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->preRotate(degrees, px, py); } - static void preRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { + static void preRotate__F(jlong objHandle, jfloat degrees) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->preRotate(degrees); } - static void preSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { + static void preSkew__FFFF(jlong objHandle, jfloat kx, jfloat ky, jfloat px, + jfloat py) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->preSkew(kx, ky, px, py); } - static void preSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) { + static void preSkew__FF(jlong objHandle, jfloat kx, jfloat ky) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->preSkew(kx, ky); } - static void preConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) { + static void preConcat(jlong objHandle, jlong otherHandle) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); obj->preConcat(*other); } - static void postTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + static void postTranslate(jlong objHandle, jfloat dx, jfloat dy) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->postTranslate(dx, dy); } - static void postScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { + static void postScale__FFFF(jlong objHandle, jfloat sx, jfloat sy, + jfloat px, jfloat py) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->postScale(sx, sy, px, py); } - static void postScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { + static void postScale__FF(jlong objHandle, jfloat sx, jfloat sy) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->postScale(sx, sy); } - static void postRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { + static void postRotate__FFF(jlong objHandle, jfloat degrees, jfloat px, + jfloat py) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->postRotate(degrees, px, py); } - static void postRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { + static void postRotate__F(jlong objHandle, jfloat degrees) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->postRotate(degrees); } - static void postSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { + static void postSkew__FFFF(jlong objHandle, jfloat kx, jfloat ky, jfloat px, + jfloat py) { SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->postSkew(kx, ky, px, py); } - static void postSkew__FF(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat kx, jfloat ky) { + static void postSkew__FF(jlong matrixHandle, jfloat kx, jfloat ky) { SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); matrix->postSkew(kx, ky); } - static void postConcat(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong otherHandle) { + static void postConcat(jlong matrixHandle, jlong otherHandle) { SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); matrix->postConcat(*other); } - static jboolean setRectToRect(JNIEnv* env, jobject clazz, jlong matrixHandle, jobject src, jobject dst, jint stfHandle) { - SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); - SkMatrix::ScaleToFit stf = static_cast<SkMatrix::ScaleToFit>(stfHandle); - SkRect src_; - GraphicsJNI::jrectf_to_rect(env, src, &src_); - SkRect dst_; - GraphicsJNI::jrectf_to_rect(env, dst, &dst_); - return matrix->setRectToRect(src_, dst_, stf) ? JNI_TRUE : JNI_FALSE; - } - - static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, jlong matrixHandle, - jfloatArray jsrc, jint srcIndex, - jfloatArray jdst, jint dstIndex, jint ptCount) { - SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); - SkASSERT(srcIndex >= 0); - SkASSERT(dstIndex >= 0); - SkASSERT((unsigned)ptCount <= 4); - - AutoJavaFloatArray autoSrc(env, jsrc, srcIndex + (ptCount << 1), kRO_JNIAccess); - AutoJavaFloatArray autoDst(env, jdst, dstIndex + (ptCount << 1), kRW_JNIAccess); - float* src = autoSrc.ptr() + srcIndex; - float* dst = autoDst.ptr() + dstIndex; - bool result; - -#ifdef SK_SCALAR_IS_FLOAT - result = matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst, - ptCount); -#else - SkASSERT(false); -#endif - return result ? JNI_TRUE : JNI_FALSE; - } - - static jboolean invert(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong inverseHandle) { + static jboolean invert(jlong matrixHandle, jlong inverseHandle) { SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); SkMatrix* inverse = reinterpret_cast<SkMatrix*>(inverseHandle); return matrix->invert(inverse); } - static void mapPoints(JNIEnv* env, jobject clazz, jlong matrixHandle, - jfloatArray dst, jint dstIndex, - jfloatArray src, jint srcIndex, - jint ptCount, jboolean isPts) { - SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); - SkASSERT(ptCount >= 0); - AutoJavaFloatArray autoSrc(env, src, srcIndex + (ptCount << 1), kRO_JNIAccess); - AutoJavaFloatArray autoDst(env, dst, dstIndex + (ptCount << 1), kRW_JNIAccess); - float* srcArray = autoSrc.ptr() + srcIndex; - float* dstArray = autoDst.ptr() + dstIndex; -#ifdef SK_SCALAR_IS_FLOAT - if (isPts) - matrix->mapPoints((SkPoint*)dstArray, (const SkPoint*)srcArray, - ptCount); - else - matrix->mapVectors((SkVector*)dstArray, (const SkVector*)srcArray, - ptCount); -#else - SkASSERT(false); -#endif - } - - static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, jlong matrixHandle, jobjectArray dst, jobject src) { - SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); - SkRect dst_, src_; - GraphicsJNI::jrectf_to_rect(env, src, &src_); - jboolean rectStaysRect = matrix->mapRect(&dst_, src_); - GraphicsJNI::rect_to_jrectf(dst_, env, dst); - return rectStaysRect ? JNI_TRUE : JNI_FALSE; - } - - static jfloat mapRadius(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat radius) { + static jfloat mapRadius(jlong matrixHandle, jfloat radius) { SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); float result; result = SkScalarToFloat(matrix->mapRadius(radius)); return static_cast<jfloat>(result); } - static void getValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) { - SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); - AutoJavaFloatArray autoValues(env, values, 9, kRW_JNIAccess); - float* dst = autoValues.ptr(); -#ifdef SK_SCALAR_IS_FLOAT - for (int i = 0; i < 9; i++) { - dst[i] = matrix->get(i); - } -#else - SkASSERT(false); -#endif - } - static void setValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) { - SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); - AutoJavaFloatArray autoValues(env, values, 9, kRO_JNIAccess); - const float* src = autoValues.ptr(); - -#ifdef SK_SCALAR_IS_FLOAT - for (int i = 0; i < 9; i++) { - matrix->set(i, src[i]); - } -#else - SkASSERT(false); -#endif - } - - static jboolean equals(JNIEnv* env, jobject clazz, jlong aHandle, jlong bHandle) { + static jboolean equals(jlong aHandle, jlong bHandle) { const SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle); const SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle); return *a == *b; } - }; +}; static const JNINativeMethod methods[] = { - {"finalizer", "(J)V", (void*) SkMatrixGlue::finalizer}, - {"native_create","(J)J", (void*) SkMatrixGlue::create}, - - {"native_isIdentity","!(J)Z", (void*) SkMatrixGlue::isIdentity}, - {"native_isAffine","!(J)Z", (void*) SkMatrixGlue::isAffine}, - {"native_rectStaysRect","!(J)Z", (void*) SkMatrixGlue::rectStaysRect}, - {"native_reset","!(J)V", (void*) SkMatrixGlue::reset}, - {"native_set","!(JJ)V", (void*) SkMatrixGlue::set}, - {"native_setTranslate","!(JFF)V", (void*) SkMatrixGlue::setTranslate}, - {"native_setScale","!(JFFFF)V", (void*) SkMatrixGlue::setScale__FFFF}, - {"native_setScale","!(JFF)V", (void*) SkMatrixGlue::setScale__FF}, - {"native_setRotate","!(JFFF)V", (void*) SkMatrixGlue::setRotate__FFF}, - {"native_setRotate","!(JF)V", (void*) SkMatrixGlue::setRotate__F}, - {"native_setSinCos","!(JFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF}, - {"native_setSinCos","!(JFF)V", (void*) SkMatrixGlue::setSinCos__FF}, - {"native_setSkew","!(JFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF}, - {"native_setSkew","!(JFF)V", (void*) SkMatrixGlue::setSkew__FF}, - {"native_setConcat","!(JJJ)V", (void*) SkMatrixGlue::setConcat}, - {"native_preTranslate","!(JFF)V", (void*) SkMatrixGlue::preTranslate}, - {"native_preScale","!(JFFFF)V", (void*) SkMatrixGlue::preScale__FFFF}, - {"native_preScale","!(JFF)V", (void*) SkMatrixGlue::preScale__FF}, - {"native_preRotate","!(JFFF)V", (void*) SkMatrixGlue::preRotate__FFF}, - {"native_preRotate","!(JF)V", (void*) SkMatrixGlue::preRotate__F}, - {"native_preSkew","!(JFFFF)V", (void*) SkMatrixGlue::preSkew__FFFF}, - {"native_preSkew","!(JFF)V", (void*) SkMatrixGlue::preSkew__FF}, - {"native_preConcat","!(JJ)V", (void*) SkMatrixGlue::preConcat}, - {"native_postTranslate","!(JFF)V", (void*) SkMatrixGlue::postTranslate}, - {"native_postScale","!(JFFFF)V", (void*) SkMatrixGlue::postScale__FFFF}, - {"native_postScale","!(JFF)V", (void*) SkMatrixGlue::postScale__FF}, - {"native_postRotate","!(JFFF)V", (void*) SkMatrixGlue::postRotate__FFF}, - {"native_postRotate","!(JF)V", (void*) SkMatrixGlue::postRotate__F}, - {"native_postSkew","!(JFFFF)V", (void*) SkMatrixGlue::postSkew__FFFF}, - {"native_postSkew","!(JFF)V", (void*) SkMatrixGlue::postSkew__FF}, - {"native_postConcat","!(JJ)V", (void*) SkMatrixGlue::postConcat}, - {"native_setRectToRect","!(JLandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect}, - {"native_setPolyToPoly","!(J[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly}, - {"native_invert","!(JJ)Z", (void*) SkMatrixGlue::invert}, - {"native_mapPoints","!(J[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints}, - {"native_mapRect","!(JLandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF}, - {"native_mapRadius","!(JF)F", (void*) SkMatrixGlue::mapRadius}, - {"native_getValues","!(J[F)V", (void*) SkMatrixGlue::getValues}, - {"native_setValues","!(J[F)V", (void*) SkMatrixGlue::setValues}, - {"native_equals", "!(JJ)Z", (void*) SkMatrixGlue::equals} + {"nGetNativeFinalizer", "()J", (void*) SkMatrixGlue::getNativeFinalizer}, + {"nCreate","(J)J", (void*) SkMatrixGlue::create}, + + // ------- @FastNative below here --------------- + {"nMapPoints","(J[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints}, + {"nMapRect","(JLandroid/graphics/RectF;Landroid/graphics/RectF;)Z", + (void*) SkMatrixGlue::mapRect__RectFRectF}, + {"nSetRectToRect","(JLandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", + (void*) SkMatrixGlue::setRectToRect}, + {"nSetPolyToPoly","(J[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly}, + {"nGetValues","(J[F)V", (void*) SkMatrixGlue::getValues}, + {"nSetValues","(J[F)V", (void*) SkMatrixGlue::setValues}, + + // ------- @CriticalNative below here --------------- + {"nIsIdentity","(J)Z", (void*) SkMatrixGlue::isIdentity}, + {"nIsAffine","(J)Z", (void*) SkMatrixGlue::isAffine}, + {"nRectStaysRect","(J)Z", (void*) SkMatrixGlue::rectStaysRect}, + {"nReset","(J)V", (void*) SkMatrixGlue::reset}, + {"nSet","(JJ)V", (void*) SkMatrixGlue::set}, + {"nSetTranslate","(JFF)V", (void*) SkMatrixGlue::setTranslate}, + {"nSetScale","(JFFFF)V", (void*) SkMatrixGlue::setScale__FFFF}, + {"nSetScale","(JFF)V", (void*) SkMatrixGlue::setScale__FF}, + {"nSetRotate","(JFFF)V", (void*) SkMatrixGlue::setRotate__FFF}, + {"nSetRotate","(JF)V", (void*) SkMatrixGlue::setRotate__F}, + {"nSetSinCos","(JFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF}, + {"nSetSinCos","(JFF)V", (void*) SkMatrixGlue::setSinCos__FF}, + {"nSetSkew","(JFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF}, + {"nSetSkew","(JFF)V", (void*) SkMatrixGlue::setSkew__FF}, + {"nSetConcat","(JJJ)V", (void*) SkMatrixGlue::setConcat}, + {"nPreTranslate","(JFF)V", (void*) SkMatrixGlue::preTranslate}, + {"nPreScale","(JFFFF)V", (void*) SkMatrixGlue::preScale__FFFF}, + {"nPreScale","(JFF)V", (void*) SkMatrixGlue::preScale__FF}, + {"nPreRotate","(JFFF)V", (void*) SkMatrixGlue::preRotate__FFF}, + {"nPreRotate","(JF)V", (void*) SkMatrixGlue::preRotate__F}, + {"nPreSkew","(JFFFF)V", (void*) SkMatrixGlue::preSkew__FFFF}, + {"nPreSkew","(JFF)V", (void*) SkMatrixGlue::preSkew__FF}, + {"nPreConcat","(JJ)V", (void*) SkMatrixGlue::preConcat}, + {"nPostTranslate","(JFF)V", (void*) SkMatrixGlue::postTranslate}, + {"nPostScale","(JFFFF)V", (void*) SkMatrixGlue::postScale__FFFF}, + {"nPostScale","(JFF)V", (void*) SkMatrixGlue::postScale__FF}, + {"nPostRotate","(JFFF)V", (void*) SkMatrixGlue::postRotate__FFF}, + {"nPostRotate","(JF)V", (void*) SkMatrixGlue::postRotate__F}, + {"nPostSkew","(JFFFF)V", (void*) SkMatrixGlue::postSkew__FFFF}, + {"nPostSkew","(JFF)V", (void*) SkMatrixGlue::postSkew__FF}, + {"nPostConcat","(JJ)V", (void*) SkMatrixGlue::postConcat}, + {"nInvert","(JJ)Z", (void*) SkMatrixGlue::invert}, + {"nMapRadius","(JF)F", (void*) SkMatrixGlue::mapRadius}, + {"nEquals", "(JJ)Z", (void*) SkMatrixGlue::equals} }; static jfieldID sNativeInstanceField; diff --git a/graphics/java/android/graphics/Matrix.java b/graphics/java/android/graphics/Matrix.java index 1e8f11bbe3ed..35cedae1e49a 100644 --- a/graphics/java/android/graphics/Matrix.java +++ b/graphics/java/android/graphics/Matrix.java @@ -16,8 +16,12 @@ package android.graphics; -import java.io.PrintWriter; +import dalvik.annotation.optimization.CriticalNative; +import dalvik.annotation.optimization.FastNative; + +import libcore.util.NativeAllocationRegistry; +import java.io.PrintWriter; /** * The Matrix class holds a 3x3 matrix for transforming coordinates. @@ -216,352 +220,345 @@ public class Matrix { } }; + // sizeof(SkMatrix) is 9 * sizeof(float) + uint32_t + private static final long NATIVE_ALLOCATION_SIZE = 40; + + private static class NoImagePreloadHolder { + public static final NativeAllocationRegistry sRegistry = new NativeAllocationRegistry( + Matrix.class.getClassLoader(), nGetNativeFinalizer(), NATIVE_ALLOCATION_SIZE); + } + /** * @hide */ - public long native_instance; + public final long native_instance; /** * Create an identity matrix */ public Matrix() { - native_instance = native_create(0); + native_instance = nCreate(0); + NoImagePreloadHolder.sRegistry.registerNativeAllocation(this, native_instance); } /** * Create a matrix that is a (deep) copy of src + * * @param src The matrix to copy into this matrix */ public Matrix(Matrix src) { - native_instance = native_create(src != null ? src.native_instance : 0); + native_instance = nCreate(src != null ? src.native_instance : 0); + NoImagePreloadHolder.sRegistry.registerNativeAllocation(this, native_instance); } /** - * Returns true if the matrix is identity. - * This maybe faster than testing if (getType() == 0) + * Returns true if the matrix is identity. This maybe faster than testing if (getType() == 0) */ public boolean isIdentity() { - return native_isIdentity(native_instance); + return nIsIdentity(native_instance); } /** - * Gets whether this matrix is affine. An affine matrix preserves - * straight lines and has no perspective. + * Gets whether this matrix is affine. An affine matrix preserves straight lines and has no + * perspective. * * @return Whether the matrix is affine. */ public boolean isAffine() { - return native_isAffine(native_instance); + return nIsAffine(native_instance); } /** - * Returns true if will map a rectangle to another rectangle. This can be - * true if the matrix is identity, scale-only, or rotates a multiple of 90 - * degrees. + * Returns true if will map a rectangle to another rectangle. This can be true if the matrix is + * identity, scale-only, or rotates a multiple of 90 degrees. */ public boolean rectStaysRect() { - return native_rectStaysRect(native_instance); + return nRectStaysRect(native_instance); } /** - * (deep) copy the src matrix into this matrix. If src is null, reset this - * matrix to the identity matrix. + * (deep) copy the src matrix into this matrix. If src is null, reset this matrix to the + * identity matrix. */ public void set(Matrix src) { if (src == null) { reset(); } else { - native_set(native_instance, src.native_instance); + nSet(native_instance, src.native_instance); } } - /** Returns true iff obj is a Matrix and its values equal our values. - */ + /** + * Returns true iff obj is a Matrix and its values equal our values. + */ @Override public boolean equals(Object obj) { - //if (obj == this) return true; -- NaN value would mean matrix != itself - if (!(obj instanceof Matrix)) return false; - return native_equals(native_instance, ((Matrix)obj).native_instance); + // if (obj == this) return true; -- NaN value would mean matrix != itself + if (!(obj instanceof Matrix)) { + return false; + } + return nEquals(native_instance, ((Matrix) obj).native_instance); } @Override public int hashCode() { // This should generate the hash code by performing some arithmetic operation on all // the matrix elements -- our equals() does an element-by-element comparison, and we - // need to ensure that the hash code for two equal objects is the same. We're not + // need to ensure that the hash code for two equal objects is the same. We're not // really using this at the moment, so we take the easy way out. return 44; } /** Set the matrix to identity */ public void reset() { - native_reset(native_instance); + nReset(native_instance); } /** Set the matrix to translate by (dx, dy). */ public void setTranslate(float dx, float dy) { - native_setTranslate(native_instance, dx, dy); + nSetTranslate(native_instance, dx, dy); } /** - * Set the matrix to scale by sx and sy, with a pivot point at (px, py). - * The pivot point is the coordinate that should remain unchanged by the - * specified transformation. + * Set the matrix to scale by sx and sy, with a pivot point at (px, py). The pivot point is the + * coordinate that should remain unchanged by the specified transformation. */ public void setScale(float sx, float sy, float px, float py) { - native_setScale(native_instance, sx, sy, px, py); + nSetScale(native_instance, sx, sy, px, py); } /** Set the matrix to scale by sx and sy. */ public void setScale(float sx, float sy) { - native_setScale(native_instance, sx, sy); + nSetScale(native_instance, sx, sy); } /** - * Set the matrix to rotate by the specified number of degrees, with a pivot - * point at (px, py). The pivot point is the coordinate that should remain - * unchanged by the specified transformation. + * Set the matrix to rotate by the specified number of degrees, with a pivot point at (px, py). + * The pivot point is the coordinate that should remain unchanged by the specified + * transformation. */ public void setRotate(float degrees, float px, float py) { - native_setRotate(native_instance, degrees, px, py); + nSetRotate(native_instance, degrees, px, py); } /** * Set the matrix to rotate about (0,0) by the specified number of degrees. */ public void setRotate(float degrees) { - native_setRotate(native_instance, degrees); + nSetRotate(native_instance, degrees); } /** - * Set the matrix to rotate by the specified sine and cosine values, with a - * pivot point at (px, py). The pivot point is the coordinate that should - * remain unchanged by the specified transformation. + * Set the matrix to rotate by the specified sine and cosine values, with a pivot point at (px, + * py). The pivot point is the coordinate that should remain unchanged by the specified + * transformation. */ public void setSinCos(float sinValue, float cosValue, float px, float py) { - native_setSinCos(native_instance, sinValue, cosValue, px, py); + nSetSinCos(native_instance, sinValue, cosValue, px, py); } /** Set the matrix to rotate by the specified sine and cosine values. */ public void setSinCos(float sinValue, float cosValue) { - native_setSinCos(native_instance, sinValue, cosValue); + nSetSinCos(native_instance, sinValue, cosValue); } /** - * Set the matrix to skew by sx and sy, with a pivot point at (px, py). - * The pivot point is the coordinate that should remain unchanged by the - * specified transformation. + * Set the matrix to skew by sx and sy, with a pivot point at (px, py). The pivot point is the + * coordinate that should remain unchanged by the specified transformation. */ public void setSkew(float kx, float ky, float px, float py) { - native_setSkew(native_instance, kx, ky, px, py); + nSetSkew(native_instance, kx, ky, px, py); } /** Set the matrix to skew by sx and sy. */ public void setSkew(float kx, float ky) { - native_setSkew(native_instance, kx, ky); + nSetSkew(native_instance, kx, ky); } /** - * Set the matrix to the concatenation of the two specified matrices and - * return true. - * - * <p>Either of the two matrices may also be the target matrix, that is - * <code>matrixA.setConcat(matrixA, matrixB);</code> is valid.</p> - * - * <p class="note">In {@link android.os.Build.VERSION_CODES#GINGERBREAD_MR1} and below, this - * function returns true only if the result can be represented. In - * {@link android.os.Build.VERSION_CODES#HONEYCOMB} and above, it always returns true.</p> + * Set the matrix to the concatenation of the two specified matrices and return true. + * <p> + * Either of the two matrices may also be the target matrix, that is + * <code>matrixA.setConcat(matrixA, matrixB);</code> is valid. + * </p> + * <p class="note"> + * In {@link android.os.Build.VERSION_CODES#GINGERBREAD_MR1} and below, this function returns + * true only if the result can be represented. In + * {@link android.os.Build.VERSION_CODES#HONEYCOMB} and above, it always returns true. + * </p> */ public boolean setConcat(Matrix a, Matrix b) { - native_setConcat(native_instance, a.native_instance, b.native_instance); + nSetConcat(native_instance, a.native_instance, b.native_instance); return true; } /** - * Preconcats the matrix with the specified translation. - * M' = M * T(dx, dy) + * Preconcats the matrix with the specified translation. M' = M * T(dx, dy) */ public boolean preTranslate(float dx, float dy) { - native_preTranslate(native_instance, dx, dy); + nPreTranslate(native_instance, dx, dy); return true; } /** - * Preconcats the matrix with the specified scale. - * M' = M * S(sx, sy, px, py) + * Preconcats the matrix with the specified scale. M' = M * S(sx, sy, px, py) */ public boolean preScale(float sx, float sy, float px, float py) { - native_preScale(native_instance, sx, sy, px, py); + nPreScale(native_instance, sx, sy, px, py); return true; } /** - * Preconcats the matrix with the specified scale. - * M' = M * S(sx, sy) + * Preconcats the matrix with the specified scale. M' = M * S(sx, sy) */ public boolean preScale(float sx, float sy) { - native_preScale(native_instance, sx, sy); + nPreScale(native_instance, sx, sy); return true; } /** - * Preconcats the matrix with the specified rotation. - * M' = M * R(degrees, px, py) + * Preconcats the matrix with the specified rotation. M' = M * R(degrees, px, py) */ public boolean preRotate(float degrees, float px, float py) { - native_preRotate(native_instance, degrees, px, py); + nPreRotate(native_instance, degrees, px, py); return true; } /** - * Preconcats the matrix with the specified rotation. - * M' = M * R(degrees) + * Preconcats the matrix with the specified rotation. M' = M * R(degrees) */ public boolean preRotate(float degrees) { - native_preRotate(native_instance, degrees); + nPreRotate(native_instance, degrees); return true; } /** - * Preconcats the matrix with the specified skew. - * M' = M * K(kx, ky, px, py) + * Preconcats the matrix with the specified skew. M' = M * K(kx, ky, px, py) */ public boolean preSkew(float kx, float ky, float px, float py) { - native_preSkew(native_instance, kx, ky, px, py); + nPreSkew(native_instance, kx, ky, px, py); return true; } /** - * Preconcats the matrix with the specified skew. - * M' = M * K(kx, ky) + * Preconcats the matrix with the specified skew. M' = M * K(kx, ky) */ public boolean preSkew(float kx, float ky) { - native_preSkew(native_instance, kx, ky); + nPreSkew(native_instance, kx, ky); return true; } /** - * Preconcats the matrix with the specified matrix. - * M' = M * other + * Preconcats the matrix with the specified matrix. M' = M * other */ public boolean preConcat(Matrix other) { - native_preConcat(native_instance, other.native_instance); + nPreConcat(native_instance, other.native_instance); return true; } /** - * Postconcats the matrix with the specified translation. - * M' = T(dx, dy) * M + * Postconcats the matrix with the specified translation. M' = T(dx, dy) * M */ public boolean postTranslate(float dx, float dy) { - native_postTranslate(native_instance, dx, dy); + nPostTranslate(native_instance, dx, dy); return true; } /** - * Postconcats the matrix with the specified scale. - * M' = S(sx, sy, px, py) * M + * Postconcats the matrix with the specified scale. M' = S(sx, sy, px, py) * M */ public boolean postScale(float sx, float sy, float px, float py) { - native_postScale(native_instance, sx, sy, px, py); + nPostScale(native_instance, sx, sy, px, py); return true; } /** - * Postconcats the matrix with the specified scale. - * M' = S(sx, sy) * M + * Postconcats the matrix with the specified scale. M' = S(sx, sy) * M */ public boolean postScale(float sx, float sy) { - native_postScale(native_instance, sx, sy); + nPostScale(native_instance, sx, sy); return true; } /** - * Postconcats the matrix with the specified rotation. - * M' = R(degrees, px, py) * M + * Postconcats the matrix with the specified rotation. M' = R(degrees, px, py) * M */ public boolean postRotate(float degrees, float px, float py) { - native_postRotate(native_instance, degrees, px, py); + nPostRotate(native_instance, degrees, px, py); return true; } /** - * Postconcats the matrix with the specified rotation. - * M' = R(degrees) * M + * Postconcats the matrix with the specified rotation. M' = R(degrees) * M */ public boolean postRotate(float degrees) { - native_postRotate(native_instance, degrees); + nPostRotate(native_instance, degrees); return true; } /** - * Postconcats the matrix with the specified skew. - * M' = K(kx, ky, px, py) * M + * Postconcats the matrix with the specified skew. M' = K(kx, ky, px, py) * M */ public boolean postSkew(float kx, float ky, float px, float py) { - native_postSkew(native_instance, kx, ky, px, py); + nPostSkew(native_instance, kx, ky, px, py); return true; } /** - * Postconcats the matrix with the specified skew. - * M' = K(kx, ky) * M + * Postconcats the matrix with the specified skew. M' = K(kx, ky) * M */ public boolean postSkew(float kx, float ky) { - native_postSkew(native_instance, kx, ky); + nPostSkew(native_instance, kx, ky); return true; } /** - * Postconcats the matrix with the specified matrix. - * M' = other * M + * Postconcats the matrix with the specified matrix. M' = other * M */ public boolean postConcat(Matrix other) { - native_postConcat(native_instance, other.native_instance); + nPostConcat(native_instance, other.native_instance); return true; } - /** Controlls how the src rect should align into the dst rect for - setRectToRect(). - */ + /** + * Controlls how the src rect should align into the dst rect for setRectToRect(). + */ public enum ScaleToFit { /** - * Scale in X and Y independently, so that src matches dst exactly. - * This may change the aspect ratio of the src. + * Scale in X and Y independently, so that src matches dst exactly. This may change the + * aspect ratio of the src. */ - FILL (0), + FILL(0), /** - * Compute a scale that will maintain the original src aspect ratio, - * but will also ensure that src fits entirely inside dst. At least one - * axis (X or Y) will fit exactly. START aligns the result to the - * left and top edges of dst. + * Compute a scale that will maintain the original src aspect ratio, but will also ensure + * that src fits entirely inside dst. At least one axis (X or Y) will fit exactly. START + * aligns the result to the left and top edges of dst. */ - START (1), + START(1), /** - * Compute a scale that will maintain the original src aspect ratio, - * but will also ensure that src fits entirely inside dst. At least one - * axis (X or Y) will fit exactly. The result is centered inside dst. + * Compute a scale that will maintain the original src aspect ratio, but will also ensure + * that src fits entirely inside dst. At least one axis (X or Y) will fit exactly. The + * result is centered inside dst. */ - CENTER (2), + CENTER(2), /** - * Compute a scale that will maintain the original src aspect ratio, - * but will also ensure that src fits entirely inside dst. At least one - * axis (X or Y) will fit exactly. END aligns the result to the - * right and bottom edges of dst. + * Compute a scale that will maintain the original src aspect ratio, but will also ensure + * that src fits entirely inside dst. At least one axis (X or Y) will fit exactly. END + * aligns the result to the right and bottom edges of dst. */ - END (3); + END(3); // the native values must match those in SkMatrix.h ScaleToFit(int nativeInt) { this.nativeInt = nativeInt; } + final int nativeInt; } /** - * Set the matrix to the scale and translate values that map the source - * rectangle to the destination rectangle, returning true if the the result - * can be represented. + * Set the matrix to the scale and translate values that map the source rectangle to the + * destination rectangle, returning true if the the result can be represented. * * @param src the source rectangle to map from. * @param dst the destination rectangle to map to. @@ -572,13 +569,13 @@ public class Matrix { if (dst == null || src == null) { throw new NullPointerException(); } - return native_setRectToRect(native_instance, src, dst, stf.nativeInt); + return nSetRectToRect(native_instance, src, dst, stf.nativeInt); } // private helper to perform range checks on arrays of "points" private static void checkPointArrays(float[] src, int srcIndex, - float[] dst, int dstIndex, - int pointCount) { + float[] dst, int dstIndex, + int pointCount) { // check for too-small and too-big indices int srcStop = srcIndex + (pointCount << 1); int dstStop = dstIndex + (pointCount << 1); @@ -589,84 +586,81 @@ public class Matrix { } /** - * Set the matrix such that the specified src points would map to the - * specified dst points. The "points" are represented as an array of floats, - * order [x0, y0, x1, y1, ...], where each "point" is 2 float values. + * Set the matrix such that the specified src points would map to the specified dst points. The + * "points" are represented as an array of floats, order [x0, y0, x1, y1, ...], where each + * "point" is 2 float values. * - * @param src The array of src [x,y] pairs (points) + * @param src The array of src [x,y] pairs (points) * @param srcIndex Index of the first pair of src values - * @param dst The array of dst [x,y] pairs (points) + * @param dst The array of dst [x,y] pairs (points) * @param dstIndex Index of the first pair of dst values * @param pointCount The number of pairs/points to be used. Must be [0..4] * @return true if the matrix was set to the specified transformation */ public boolean setPolyToPoly(float[] src, int srcIndex, - float[] dst, int dstIndex, - int pointCount) { + float[] dst, int dstIndex, + int pointCount) { if (pointCount > 4) { throw new IllegalArgumentException(); } checkPointArrays(src, srcIndex, dst, dstIndex, pointCount); - return native_setPolyToPoly(native_instance, src, srcIndex, - dst, dstIndex, pointCount); + return nSetPolyToPoly(native_instance, src, srcIndex, + dst, dstIndex, pointCount); } /** - * If this matrix can be inverted, return true and if inverse is not null, - * set inverse to be the inverse of this matrix. If this matrix cannot be - * inverted, ignore inverse and return false. + * If this matrix can be inverted, return true and if inverse is not null, set inverse to be the + * inverse of this matrix. If this matrix cannot be inverted, ignore inverse and return false. */ public boolean invert(Matrix inverse) { - return native_invert(native_instance, inverse.native_instance); + return nInvert(native_instance, inverse.native_instance); } /** - * Apply this matrix to the array of 2D points specified by src, and write - * the transformed points into the array of points specified by dst. The - * two arrays represent their "points" as pairs of floats [x, y]. + * Apply this matrix to the array of 2D points specified by src, and write the transformed + * points into the array of points specified by dst. The two arrays represent their "points" as + * pairs of floats [x, y]. * - * @param dst The array of dst points (x,y pairs) + * @param dst The array of dst points (x,y pairs) * @param dstIndex The index of the first [x,y] pair of dst floats - * @param src The array of src points (x,y pairs) + * @param src The array of src points (x,y pairs) * @param srcIndex The index of the first [x,y] pair of src floats * @param pointCount The number of points (x,y pairs) to transform */ public void mapPoints(float[] dst, int dstIndex, float[] src, int srcIndex, - int pointCount) { + int pointCount) { checkPointArrays(src, srcIndex, dst, dstIndex, pointCount); - native_mapPoints(native_instance, dst, dstIndex, src, srcIndex, - pointCount, true); + nMapPoints(native_instance, dst, dstIndex, src, srcIndex, + pointCount, true); } /** - * Apply this matrix to the array of 2D vectors specified by src, and write - * the transformed vectors into the array of vectors specified by dst. The - * two arrays represent their "vectors" as pairs of floats [x, y]. + * Apply this matrix to the array of 2D vectors specified by src, and write the transformed + * vectors into the array of vectors specified by dst. The two arrays represent their "vectors" + * as pairs of floats [x, y]. Note: this method does not apply the translation associated with + * the matrix. Use {@link Matrix#mapPoints(float[], int, float[], int, int)} if you want the + * translation to be applied. * - * Note: this method does not apply the translation associated with the matrix. Use - * {@link Matrix#mapPoints(float[], int, float[], int, int)} if you want the translation - * to be applied. - * - * @param dst The array of dst vectors (x,y pairs) + * @param dst The array of dst vectors (x,y pairs) * @param dstIndex The index of the first [x,y] pair of dst floats - * @param src The array of src vectors (x,y pairs) + * @param src The array of src vectors (x,y pairs) * @param srcIndex The index of the first [x,y] pair of src floats * @param vectorCount The number of vectors (x,y pairs) to transform */ public void mapVectors(float[] dst, int dstIndex, float[] src, int srcIndex, - int vectorCount) { + int vectorCount) { checkPointArrays(src, srcIndex, dst, dstIndex, vectorCount); - native_mapPoints(native_instance, dst, dstIndex, src, srcIndex, - vectorCount, false); + nMapPoints(native_instance, dst, dstIndex, src, srcIndex, + vectorCount, false); } /** - * Apply this matrix to the array of 2D points specified by src, and write - * the transformed points into the array of points specified by dst. The - * two arrays represent their "points" as pairs of floats [x, y]. + * Apply this matrix to the array of 2D points specified by src, and write the transformed + * points into the array of points specified by dst. The two arrays represent their "points" as + * pairs of floats [x, y]. * - * @param dst The array of dst points (x,y pairs) - * @param src The array of src points (x,y pairs) + * @param dst The array of dst points (x,y pairs) + * @param src The array of src points (x,y pairs) */ public void mapPoints(float[] dst, float[] src) { if (dst.length != src.length) { @@ -676,15 +670,14 @@ public class Matrix { } /** - * Apply this matrix to the array of 2D vectors specified by src, and write - * the transformed vectors into the array of vectors specified by dst. The - * two arrays represent their "vectors" as pairs of floats [x, y]. - * - * Note: this method does not apply the translation associated with the matrix. Use - * {@link Matrix#mapPoints(float[], float[])} if you want the translation to be applied. + * Apply this matrix to the array of 2D vectors specified by src, and write the transformed + * vectors into the array of vectors specified by dst. The two arrays represent their "vectors" + * as pairs of floats [x, y]. Note: this method does not apply the translation associated with + * the matrix. Use {@link Matrix#mapPoints(float[], float[])} if you want the translation to be + * applied. * - * @param dst The array of dst vectors (x,y pairs) - * @param src The array of src vectors (x,y pairs) + * @param dst The array of dst vectors (x,y pairs) + * @param src The array of src vectors (x,y pairs) */ public void mapVectors(float[] dst, float[] src) { if (dst.length != src.length) { @@ -694,8 +687,8 @@ public class Matrix { } /** - * Apply this matrix to the array of 2D points, and write the transformed - * points back into the array + * Apply this matrix to the array of 2D points, and write the transformed points back into the + * array * * @param pts The array [x0, y0, x1, y1, ...] of points to transform. */ @@ -704,10 +697,8 @@ public class Matrix { } /** - * Apply this matrix to the array of 2D vectors, and write the transformed - * vectors back into the array. - * - * Note: this method does not apply the translation associated with the matrix. Use + * Apply this matrix to the array of 2D vectors, and write the transformed vectors back into the + * array. Note: this method does not apply the translation associated with the matrix. Use * {@link Matrix#mapPoints(float[])} if you want the translation to be applied. * * @param vecs The array [x0, y0, x1, y1, ...] of vectors to transform. @@ -717,9 +708,9 @@ public class Matrix { } /** - * Apply this matrix to the src rectangle, and write the transformed - * rectangle into dst. This is accomplished by transforming the 4 corners of - * src, and then setting dst to the bounds of those points. + * Apply this matrix to the src rectangle, and write the transformed rectangle into dst. This is + * accomplished by transforming the 4 corners of src, and then setting dst to the bounds of + * those points. * * @param dst Where the transformed rectangle is written. * @param src The original rectangle to be transformed. @@ -729,13 +720,13 @@ public class Matrix { if (dst == null || src == null) { throw new NullPointerException(); } - return native_mapRect(native_instance, dst, src); + return nMapRect(native_instance, dst, src); } /** - * Apply this matrix to the rectangle, and write the transformed rectangle - * back into it. This is accomplished by transforming the 4 corners of rect, - * and then setting it to the bounds of those points + * Apply this matrix to the rectangle, and write the transformed rectangle back into it. This is + * accomplished by transforming the 4 corners of rect, and then setting it to the bounds of + * those points * * @param rect The rectangle to transform. * @return the result of calling rectStaysRect() @@ -745,34 +736,33 @@ public class Matrix { } /** - * Return the mean radius of a circle after it has been mapped by - * this matrix. NOTE: in perspective this value assumes the circle - * has its center at the origin. + * Return the mean radius of a circle after it has been mapped by this matrix. NOTE: in + * perspective this value assumes the circle has its center at the origin. */ public float mapRadius(float radius) { - return native_mapRadius(native_instance, radius); + return nMapRadius(native_instance, radius); } - /** Copy 9 values from the matrix into the array. - */ + /** + * Copy 9 values from the matrix into the array. + */ public void getValues(float[] values) { if (values.length < 9) { throw new ArrayIndexOutOfBoundsException(); } - native_getValues(native_instance, values); + nGetValues(native_instance, values); } - /** Copy 9 values from the array into the matrix. - Depending on the implementation of Matrix, these may be - transformed into 16.16 integers in the Matrix, such that - a subsequent call to getValues() will not yield exactly - the same values. - */ + /** + * Copy 9 values from the array into the matrix. Depending on the implementation of Matrix, + * these may be transformed into 16.16 integers in the Matrix, such that a subsequent call to + * getValues() will not yield exactly the same values. + */ public void setValues(float[] values) { if (values.length < 9) { throw new ArrayIndexOutOfBoundsException(); } - native_setValues(native_instance, values); + nSetValues(native_instance, values); } @Override @@ -798,122 +788,155 @@ public class Matrix { float[] values = new float[9]; getValues(values); sb.append('['); - sb.append(values[0]); sb.append(", "); sb.append(values[1]); sb.append(", "); - sb.append(values[2]); sb.append("]["); - sb.append(values[3]); sb.append(", "); sb.append(values[4]); sb.append(", "); - sb.append(values[5]); sb.append("]["); - sb.append(values[6]); sb.append(", "); sb.append(values[7]); sb.append(", "); - sb.append(values[8]); sb.append(']'); + sb.append(values[0]); + sb.append(", "); + sb.append(values[1]); + sb.append(", "); + sb.append(values[2]); + sb.append("]["); + sb.append(values[3]); + sb.append(", "); + sb.append(values[4]); + sb.append(", "); + sb.append(values[5]); + sb.append("]["); + sb.append(values[6]); + sb.append(", "); + sb.append(values[7]); + sb.append(", "); + sb.append(values[8]); + sb.append(']'); } /** * Print short string, to optimize dumping. + * * @hide */ public void printShortString(PrintWriter pw) { float[] values = new float[9]; getValues(values); pw.print('['); - pw.print(values[0]); pw.print(", "); pw.print(values[1]); pw.print(", "); - pw.print(values[2]); pw.print("]["); - pw.print(values[3]); pw.print(", "); pw.print(values[4]); pw.print(", "); - pw.print(values[5]); pw.print("]["); - pw.print(values[6]); pw.print(", "); pw.print(values[7]); pw.print(", "); - pw.print(values[8]); pw.print(']'); - - } - - @Override - protected void finalize() throws Throwable { - try { - finalizer(native_instance); - native_instance = 0; // Other finalizers can still call us. - } finally { - super.finalize(); - } - } - - /*package*/ final long ni() { + pw.print(values[0]); + pw.print(", "); + pw.print(values[1]); + pw.print(", "); + pw.print(values[2]); + pw.print("]["); + pw.print(values[3]); + pw.print(", "); + pw.print(values[4]); + pw.print(", "); + pw.print(values[5]); + pw.print("]["); + pw.print(values[6]); + pw.print(", "); + pw.print(values[7]); + pw.print(", "); + pw.print(values[8]); + pw.print(']'); + + } + + /* package */ final long ni() { return native_instance; } - private static native long native_create(long native_src_or_zero); - private static native boolean native_isIdentity(long native_object); - private static native boolean native_isAffine(long native_object); - private static native boolean native_rectStaysRect(long native_object); - private static native void native_reset(long native_object); - private static native void native_set(long native_object, - long native_other); - private static native void native_setTranslate(long native_object, - float dx, float dy); - private static native void native_setScale(long native_object, - float sx, float sy, float px, float py); - private static native void native_setScale(long native_object, - float sx, float sy); - private static native void native_setRotate(long native_object, - float degrees, float px, float py); - private static native void native_setRotate(long native_object, - float degrees); - private static native void native_setSinCos(long native_object, - float sinValue, float cosValue, float px, float py); - private static native void native_setSinCos(long native_object, - float sinValue, float cosValue); - private static native void native_setSkew(long native_object, - float kx, float ky, float px, float py); - private static native void native_setSkew(long native_object, - float kx, float ky); - private static native void native_setConcat(long native_object, - long native_a, - long native_b); - private static native void native_preTranslate(long native_object, - float dx, float dy); - private static native void native_preScale(long native_object, - float sx, float sy, float px, float py); - private static native void native_preScale(long native_object, - float sx, float sy); - private static native void native_preRotate(long native_object, - float degrees, float px, float py); - private static native void native_preRotate(long native_object, - float degrees); - private static native void native_preSkew(long native_object, - float kx, float ky, float px, float py); - private static native void native_preSkew(long native_object, - float kx, float ky); - private static native void native_preConcat(long native_object, - long native_other_matrix); - private static native void native_postTranslate(long native_object, - float dx, float dy); - private static native void native_postScale(long native_object, - float sx, float sy, float px, float py); - private static native void native_postScale(long native_object, - float sx, float sy); - private static native void native_postRotate(long native_object, - float degrees, float px, float py); - private static native void native_postRotate(long native_object, - float degrees); - private static native void native_postSkew(long native_object, - float kx, float ky, float px, float py); - private static native void native_postSkew(long native_object, - float kx, float ky); - private static native void native_postConcat(long native_object, - long native_other_matrix); - private static native boolean native_setRectToRect(long native_object, - RectF src, RectF dst, int stf); - private static native boolean native_setPolyToPoly(long native_object, - float[] src, int srcIndex, float[] dst, int dstIndex, int pointCount); - private static native boolean native_invert(long native_object, - long native_inverse); - private static native void native_mapPoints(long native_object, - float[] dst, int dstIndex, float[] src, int srcIndex, - int ptCount, boolean isPts); - private static native boolean native_mapRect(long native_object, - RectF dst, RectF src); - private static native float native_mapRadius(long native_object, - float radius); - private static native void native_getValues(long native_object, - float[] values); - private static native void native_setValues(long native_object, - float[] values); - private static native boolean native_equals(long native_a, long native_b); - private static native void finalizer(long native_instance); + // ------------------ Regular JNI ------------------------ + + private static native long nCreate(long nSrc_or_zero); + private static native long nGetNativeFinalizer(); + + + // ------------------ Fast JNI ------------------------ + + @FastNative + private static native boolean nSetRectToRect(long nObject, + RectF src, RectF dst, int stf); + @FastNative + private static native boolean nSetPolyToPoly(long nObject, + float[] src, int srcIndex, float[] dst, int dstIndex, int pointCount); + @FastNative + private static native void nMapPoints(long nObject, + float[] dst, int dstIndex, float[] src, int srcIndex, + int ptCount, boolean isPts); + @FastNative + private static native boolean nMapRect(long nObject, RectF dst, RectF src); + @FastNative + private static native void nGetValues(long nObject, float[] values); + @FastNative + private static native void nSetValues(long nObject, float[] values); + + + // ------------------ Critical JNI ------------------------ + + @CriticalNative + private static native boolean nIsIdentity(long nObject); + @CriticalNative + private static native boolean nIsAffine(long nObject); + @CriticalNative + private static native boolean nRectStaysRect(long nObject); + @CriticalNative + private static native void nReset(long nObject); + @CriticalNative + private static native void nSet(long nObject, long nOther); + @CriticalNative + private static native void nSetTranslate(long nObject, float dx, float dy); + @CriticalNative + private static native void nSetScale(long nObject, float sx, float sy, float px, float py); + @CriticalNative + private static native void nSetScale(long nObject, float sx, float sy); + @CriticalNative + private static native void nSetRotate(long nObject, float degrees, float px, float py); + @CriticalNative + private static native void nSetRotate(long nObject, float degrees); + @CriticalNative + private static native void nSetSinCos(long nObject, float sinValue, float cosValue, + float px, float py); + @CriticalNative + private static native void nSetSinCos(long nObject, float sinValue, float cosValue); + @CriticalNative + private static native void nSetSkew(long nObject, float kx, float ky, float px, float py); + @CriticalNative + private static native void nSetSkew(long nObject, float kx, float ky); + @CriticalNative + private static native void nSetConcat(long nObject, long nA, long nB); + @CriticalNative + private static native void nPreTranslate(long nObject, float dx, float dy); + @CriticalNative + private static native void nPreScale(long nObject, float sx, float sy, float px, float py); + @CriticalNative + private static native void nPreScale(long nObject, float sx, float sy); + @CriticalNative + private static native void nPreRotate(long nObject, float degrees, float px, float py); + @CriticalNative + private static native void nPreRotate(long nObject, float degrees); + @CriticalNative + private static native void nPreSkew(long nObject, float kx, float ky, float px, float py); + @CriticalNative + private static native void nPreSkew(long nObject, float kx, float ky); + @CriticalNative + private static native void nPreConcat(long nObject, long nOther_matrix); + @CriticalNative + private static native void nPostTranslate(long nObject, float dx, float dy); + @CriticalNative + private static native void nPostScale(long nObject, float sx, float sy, float px, float py); + @CriticalNative + private static native void nPostScale(long nObject, float sx, float sy); + @CriticalNative + private static native void nPostRotate(long nObject, float degrees, float px, float py); + @CriticalNative + private static native void nPostRotate(long nObject, float degrees); + @CriticalNative + private static native void nPostSkew(long nObject, float kx, float ky, float px, float py); + @CriticalNative + private static native void nPostSkew(long nObject, float kx, float ky); + @CriticalNative + private static native void nPostConcat(long nObject, long nOther_matrix); + @CriticalNative + private static native boolean nInvert(long nObject, long nInverse); + @CriticalNative + private static native float nMapRadius(long nObject, float radius); + @CriticalNative + private static native boolean nEquals(long nA, long nB); } |