Graphics.cpp revision f8d8777dddf91c741981b4f795f2fb2b1d81c1b6
1#define LOG_TAG "GraphicsJNI" 2 3#include "jni.h" 4#include "JNIHelp.h" 5#include "GraphicsJNI.h" 6 7#include "SkCanvas.h" 8#include "SkDevice.h" 9#include "SkPicture.h" 10#include "SkRegion.h" 11#include <android_runtime/AndroidRuntime.h> 12 13void doThrowNPE(JNIEnv* env) { 14 jniThrowNullPointerException(env, NULL); 15} 16 17void doThrowAIOOBE(JNIEnv* env) { 18 jniThrowException(env, "java/lang/ArrayIndexOutOfBoundsException", NULL); 19} 20 21void doThrowRE(JNIEnv* env, const char* msg) { 22 jniThrowRuntimeException(env, msg); 23} 24 25void doThrowIAE(JNIEnv* env, const char* msg) { 26 jniThrowException(env, "java/lang/IllegalArgumentException", msg); 27} 28 29void doThrowISE(JNIEnv* env, const char* msg) { 30 jniThrowException(env, "java/lang/IllegalStateException", msg); 31} 32 33void doThrowOOME(JNIEnv* env, const char* msg) { 34 jniThrowException(env, "java/lang/OutOfMemoryError", msg); 35} 36 37void doThrowIOE(JNIEnv* env, const char* msg) { 38 jniThrowException(env, "java/io/IOException", msg); 39} 40 41bool GraphicsJNI::hasException(JNIEnv *env) { 42 if (env->ExceptionCheck() != 0) { 43 ALOGE("*** Uncaught exception returned from Java call!\n"); 44 env->ExceptionDescribe(); 45 return true; 46 } 47 return false; 48} 49 50/////////////////////////////////////////////////////////////////////////////// 51 52AutoJavaFloatArray::AutoJavaFloatArray(JNIEnv* env, jfloatArray array, 53 int minLength, JNIAccess access) 54: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { 55 SkASSERT(env); 56 if (array) { 57 fLen = env->GetArrayLength(array); 58 if (fLen < minLength) { 59 sk_throw(); 60 } 61 fPtr = env->GetFloatArrayElements(array, NULL); 62 } 63 fReleaseMode = (access == kRO_JNIAccess) ? JNI_ABORT : 0; 64} 65 66AutoJavaFloatArray::~AutoJavaFloatArray() { 67 if (fPtr) { 68 fEnv->ReleaseFloatArrayElements(fArray, fPtr, fReleaseMode); 69 } 70} 71 72AutoJavaIntArray::AutoJavaIntArray(JNIEnv* env, jintArray array, 73 int minLength) 74: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { 75 SkASSERT(env); 76 if (array) { 77 fLen = env->GetArrayLength(array); 78 if (fLen < minLength) { 79 sk_throw(); 80 } 81 fPtr = env->GetIntArrayElements(array, NULL); 82 } 83} 84 85AutoJavaIntArray::~AutoJavaIntArray() { 86 if (fPtr) { 87 fEnv->ReleaseIntArrayElements(fArray, fPtr, 0); 88 } 89} 90 91AutoJavaShortArray::AutoJavaShortArray(JNIEnv* env, jshortArray array, 92 int minLength, JNIAccess access) 93: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { 94 SkASSERT(env); 95 if (array) { 96 fLen = env->GetArrayLength(array); 97 if (fLen < minLength) { 98 sk_throw(); 99 } 100 fPtr = env->GetShortArrayElements(array, NULL); 101 } 102 fReleaseMode = (access == kRO_JNIAccess) ? JNI_ABORT : 0; 103} 104 105AutoJavaShortArray::~AutoJavaShortArray() { 106 if (fPtr) { 107 fEnv->ReleaseShortArrayElements(fArray, fPtr, fReleaseMode); 108 } 109} 110 111AutoJavaByteArray::AutoJavaByteArray(JNIEnv* env, jbyteArray array, 112 int minLength) 113: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { 114 SkASSERT(env); 115 if (array) { 116 fLen = env->GetArrayLength(array); 117 if (fLen < minLength) { 118 sk_throw(); 119 } 120 fPtr = env->GetByteArrayElements(array, NULL); 121 } 122} 123 124AutoJavaByteArray::~AutoJavaByteArray() { 125 if (fPtr) { 126 fEnv->ReleaseByteArrayElements(fArray, fPtr, 0); 127 } 128} 129 130/////////////////////////////////////////////////////////////////////////////// 131 132static jclass gRect_class; 133static jfieldID gRect_leftFieldID; 134static jfieldID gRect_topFieldID; 135static jfieldID gRect_rightFieldID; 136static jfieldID gRect_bottomFieldID; 137 138static jclass gRectF_class; 139static jfieldID gRectF_leftFieldID; 140static jfieldID gRectF_topFieldID; 141static jfieldID gRectF_rightFieldID; 142static jfieldID gRectF_bottomFieldID; 143 144static jclass gPoint_class; 145static jfieldID gPoint_xFieldID; 146static jfieldID gPoint_yFieldID; 147 148static jclass gPointF_class; 149static jfieldID gPointF_xFieldID; 150static jfieldID gPointF_yFieldID; 151 152static jclass gBitmap_class; 153static jfieldID gBitmap_nativeInstanceID; 154static jmethodID gBitmap_constructorMethodID; 155static jmethodID gBitmap_reinitMethodID; 156static jmethodID gBitmap_getAllocationByteCountMethodID; 157 158static jclass gBitmapConfig_class; 159static jfieldID gBitmapConfig_nativeInstanceID; 160 161static jclass gBitmapRegionDecoder_class; 162static jmethodID gBitmapRegionDecoder_constructorMethodID; 163 164static jclass gCanvas_class; 165static jfieldID gCanvas_nativeInstanceID; 166 167static jclass gPaint_class; 168static jfieldID gPaint_nativeInstanceID; 169 170static jclass gPicture_class; 171static jfieldID gPicture_nativeInstanceID; 172 173static jclass gRegion_class; 174static jfieldID gRegion_nativeInstanceID; 175static jmethodID gRegion_constructorMethodID; 176 177static jclass gByte_class; 178static jobject gVMRuntime; 179static jclass gVMRuntime_class; 180static jmethodID gVMRuntime_newNonMovableArray; 181static jmethodID gVMRuntime_addressOf; 182 183/////////////////////////////////////////////////////////////////////////////// 184 185void GraphicsJNI::get_jrect(JNIEnv* env, jobject obj, int* L, int* T, int* R, int* B) 186{ 187 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 188 189 *L = env->GetIntField(obj, gRect_leftFieldID); 190 *T = env->GetIntField(obj, gRect_topFieldID); 191 *R = env->GetIntField(obj, gRect_rightFieldID); 192 *B = env->GetIntField(obj, gRect_bottomFieldID); 193} 194 195void GraphicsJNI::set_jrect(JNIEnv* env, jobject obj, int L, int T, int R, int B) 196{ 197 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 198 199 env->SetIntField(obj, gRect_leftFieldID, L); 200 env->SetIntField(obj, gRect_topFieldID, T); 201 env->SetIntField(obj, gRect_rightFieldID, R); 202 env->SetIntField(obj, gRect_bottomFieldID, B); 203} 204 205SkIRect* GraphicsJNI::jrect_to_irect(JNIEnv* env, jobject obj, SkIRect* ir) 206{ 207 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 208 209 ir->set(env->GetIntField(obj, gRect_leftFieldID), 210 env->GetIntField(obj, gRect_topFieldID), 211 env->GetIntField(obj, gRect_rightFieldID), 212 env->GetIntField(obj, gRect_bottomFieldID)); 213 return ir; 214} 215 216void GraphicsJNI::irect_to_jrect(const SkIRect& ir, JNIEnv* env, jobject obj) 217{ 218 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 219 220 env->SetIntField(obj, gRect_leftFieldID, ir.fLeft); 221 env->SetIntField(obj, gRect_topFieldID, ir.fTop); 222 env->SetIntField(obj, gRect_rightFieldID, ir.fRight); 223 env->SetIntField(obj, gRect_bottomFieldID, ir.fBottom); 224} 225 226SkRect* GraphicsJNI::jrectf_to_rect(JNIEnv* env, jobject obj, SkRect* r) 227{ 228 SkASSERT(env->IsInstanceOf(obj, gRectF_class)); 229 230 r->set(SkFloatToScalar(env->GetFloatField(obj, gRectF_leftFieldID)), 231 SkFloatToScalar(env->GetFloatField(obj, gRectF_topFieldID)), 232 SkFloatToScalar(env->GetFloatField(obj, gRectF_rightFieldID)), 233 SkFloatToScalar(env->GetFloatField(obj, gRectF_bottomFieldID))); 234 return r; 235} 236 237SkRect* GraphicsJNI::jrect_to_rect(JNIEnv* env, jobject obj, SkRect* r) 238{ 239 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 240 241 r->set(SkIntToScalar(env->GetIntField(obj, gRect_leftFieldID)), 242 SkIntToScalar(env->GetIntField(obj, gRect_topFieldID)), 243 SkIntToScalar(env->GetIntField(obj, gRect_rightFieldID)), 244 SkIntToScalar(env->GetIntField(obj, gRect_bottomFieldID))); 245 return r; 246} 247 248void GraphicsJNI::rect_to_jrectf(const SkRect& r, JNIEnv* env, jobject obj) 249{ 250 SkASSERT(env->IsInstanceOf(obj, gRectF_class)); 251 252 env->SetFloatField(obj, gRectF_leftFieldID, SkScalarToFloat(r.fLeft)); 253 env->SetFloatField(obj, gRectF_topFieldID, SkScalarToFloat(r.fTop)); 254 env->SetFloatField(obj, gRectF_rightFieldID, SkScalarToFloat(r.fRight)); 255 env->SetFloatField(obj, gRectF_bottomFieldID, SkScalarToFloat(r.fBottom)); 256} 257 258SkIPoint* GraphicsJNI::jpoint_to_ipoint(JNIEnv* env, jobject obj, SkIPoint* point) 259{ 260 SkASSERT(env->IsInstanceOf(obj, gPoint_class)); 261 262 point->set(env->GetIntField(obj, gPoint_xFieldID), 263 env->GetIntField(obj, gPoint_yFieldID)); 264 return point; 265} 266 267void GraphicsJNI::ipoint_to_jpoint(const SkIPoint& ir, JNIEnv* env, jobject obj) 268{ 269 SkASSERT(env->IsInstanceOf(obj, gPoint_class)); 270 271 env->SetIntField(obj, gPoint_xFieldID, ir.fX); 272 env->SetIntField(obj, gPoint_yFieldID, ir.fY); 273} 274 275SkPoint* GraphicsJNI::jpointf_to_point(JNIEnv* env, jobject obj, SkPoint* point) 276{ 277 SkASSERT(env->IsInstanceOf(obj, gPointF_class)); 278 279 point->set(SkFloatToScalar(env->GetIntField(obj, gPointF_xFieldID)), 280 SkFloatToScalar(env->GetIntField(obj, gPointF_yFieldID))); 281 return point; 282} 283 284void GraphicsJNI::point_to_jpointf(const SkPoint& r, JNIEnv* env, jobject obj) 285{ 286 SkASSERT(env->IsInstanceOf(obj, gPointF_class)); 287 288 env->SetFloatField(obj, gPointF_xFieldID, SkScalarToFloat(r.fX)); 289 env->SetFloatField(obj, gPointF_yFieldID, SkScalarToFloat(r.fY)); 290} 291 292SkBitmap* GraphicsJNI::getNativeBitmap(JNIEnv* env, jobject bitmap) { 293 SkASSERT(env); 294 SkASSERT(bitmap); 295 SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class)); 296 jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativeInstanceID); 297 SkBitmap* b = reinterpret_cast<SkBitmap*>(bitmapHandle); 298 SkASSERT(b); 299 return b; 300} 301 302SkBitmap::Config GraphicsJNI::getNativeBitmapConfig(JNIEnv* env, 303 jobject jconfig) { 304 SkASSERT(env); 305 if (NULL == jconfig) { 306 return SkBitmap::kNo_Config; 307 } 308 SkASSERT(env->IsInstanceOf(jconfig, gBitmapConfig_class)); 309 int c = env->GetIntField(jconfig, gBitmapConfig_nativeInstanceID); 310 if (c < 0 || c >= SkBitmap::kConfigCount) { 311 c = SkBitmap::kNo_Config; 312 } 313 return static_cast<SkBitmap::Config>(c); 314} 315 316SkCanvas* GraphicsJNI::getNativeCanvas(JNIEnv* env, jobject canvas) { 317 SkASSERT(env); 318 SkASSERT(canvas); 319 SkASSERT(env->IsInstanceOf(canvas, gCanvas_class)); 320 jlong canvasHandle = env->GetLongField(canvas, gCanvas_nativeInstanceID); 321 SkCanvas* c = reinterpret_cast<SkCanvas*>(canvasHandle); 322 SkASSERT(c); 323 return c; 324} 325 326SkPaint* GraphicsJNI::getNativePaint(JNIEnv* env, jobject paint) { 327 SkASSERT(env); 328 SkASSERT(paint); 329 SkASSERT(env->IsInstanceOf(paint, gPaint_class)); 330 jlong paintHandle = env->GetLongField(paint, gPaint_nativeInstanceID); 331 SkPaint* p = reinterpret_cast<SkPaint*>(paintHandle); 332 SkASSERT(p); 333 return p; 334} 335 336SkPicture* GraphicsJNI::getNativePicture(JNIEnv* env, jobject picture) 337{ 338 SkASSERT(env); 339 SkASSERT(picture); 340 SkASSERT(env->IsInstanceOf(picture, gPicture_class)); 341 jlong pictureHandle = env->GetLongField(picture, gPicture_nativeInstanceID); 342 SkPicture* p = reinterpret_cast<SkPicture*>(pictureHandle); 343 SkASSERT(p); 344 return p; 345} 346 347SkRegion* GraphicsJNI::getNativeRegion(JNIEnv* env, jobject region) 348{ 349 SkASSERT(env); 350 SkASSERT(region); 351 SkASSERT(env->IsInstanceOf(region, gRegion_class)); 352 jlong regionHandle = env->GetLongField(region, gRegion_nativeInstanceID); 353 SkRegion* r = reinterpret_cast<SkRegion*>(regionHandle); 354 SkASSERT(r); 355 return r; 356} 357 358/////////////////////////////////////////////////////////////////////////////////////////// 359 360// Assert that bitmap's SkAlphaType is consistent with isPremultiplied. 361static void assert_premultiplied(const SkBitmap& bitmap, bool isPremultiplied) { 362 // kOpaque_SkAlphaType and kIgnore_SkAlphaType mean that isPremultiplied is 363 // irrelevant. This just tests to ensure that the SkAlphaType is not 364 // opposite of isPremultiplied. 365 if (isPremultiplied) { 366 SkASSERT(bitmap.alphaType() != kUnpremul_SkAlphaType); 367 } else { 368 SkASSERT(bitmap.alphaType() != kPremul_SkAlphaType); 369 } 370} 371 372jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, jbyteArray buffer, 373 int bitmapCreateFlags, jbyteArray ninepatch, jintArray layoutbounds, int density) 374{ 375 SkASSERT(bitmap); 376 SkASSERT(bitmap->pixelRef()); 377 bool isMutable = bitmapCreateFlags & kBitmapCreateFlag_Mutable; 378 bool isPremultiplied = bitmapCreateFlags & kBitmapCreateFlag_Premultiplied; 379 380 // The caller needs to have already set the alpha type properly, so the 381 // native SkBitmap stays in sync with the Java Bitmap. 382 assert_premultiplied(*bitmap, isPremultiplied); 383 384 jobject obj = env->NewObject(gBitmap_class, gBitmap_constructorMethodID, 385 reinterpret_cast<jlong>(bitmap), buffer, 386 bitmap->width(), bitmap->height(), density, isMutable, isPremultiplied, 387 ninepatch, layoutbounds); 388 hasException(env); // For the side effect of logging. 389 return obj; 390} 391 392jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, int bitmapCreateFlags, 393 jbyteArray ninepatch, int density) 394{ 395 return createBitmap(env, bitmap, NULL, bitmapCreateFlags, ninepatch, NULL, density); 396} 397 398void GraphicsJNI::reinitBitmap(JNIEnv* env, jobject javaBitmap, SkBitmap* bitmap, 399 bool isPremultiplied) 400{ 401 // The caller needs to have already set the alpha type properly, so the 402 // native SkBitmap stays in sync with the Java Bitmap. 403 assert_premultiplied(*bitmap, isPremultiplied); 404 405 env->CallVoidMethod(javaBitmap, gBitmap_reinitMethodID, 406 bitmap->width(), bitmap->height(), isPremultiplied); 407} 408 409int GraphicsJNI::getBitmapAllocationByteCount(JNIEnv* env, jobject javaBitmap) 410{ 411 return env->CallIntMethod(javaBitmap, gBitmap_getAllocationByteCountMethodID); 412} 413 414jobject GraphicsJNI::createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecoder* bitmap) 415{ 416 SkASSERT(bitmap != NULL); 417 418 jobject obj = env->NewObject(gBitmapRegionDecoder_class, 419 gBitmapRegionDecoder_constructorMethodID, 420 reinterpret_cast<jlong>(bitmap)); 421 hasException(env); // For the side effect of logging. 422 return obj; 423} 424 425jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region) 426{ 427 SkASSERT(region != NULL); 428 jobject obj = env->NewObject(gRegion_class, gRegion_constructorMethodID, 429 reinterpret_cast<jlong>(region), 0); 430 hasException(env); // For the side effect of logging. 431 return obj; 432} 433 434static JNIEnv* vm2env(JavaVM* vm) 435{ 436 JNIEnv* env = NULL; 437 if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK || NULL == env) 438 { 439 SkDebugf("------- [%p] vm->GetEnv() failed\n", vm); 440 sk_throw(); 441 } 442 return env; 443} 444 445/////////////////////////////////////////////////////////////////////////////// 446 447AndroidPixelRef::AndroidPixelRef(JNIEnv* env, const SkImageInfo& info, void* storage, 448 size_t rowBytes, jbyteArray storageObj, SkColorTable* ctable) : 449 SkMallocPixelRef(info, storage, rowBytes, ctable, (storageObj == NULL)), 450 fWrappedPixelRef(NULL) { 451 SkASSERT(storage); 452 SkASSERT(env); 453 454 if (env->GetJavaVM(&fVM) != JNI_OK) { 455 SkDebugf("------ [%p] env->GetJavaVM failed\n", env); 456 sk_throw(); 457 } 458 fStorageObj = storageObj; 459 fHasGlobalRef = false; 460 fGlobalRefCnt = 0; 461 462 // If storageObj is NULL, the memory was NOT allocated on the Java heap 463 fOnJavaHeap = (storageObj != NULL); 464} 465 466AndroidPixelRef::AndroidPixelRef(AndroidPixelRef& wrappedPixelRef, const SkImageInfo& info, 467 size_t rowBytes, SkColorTable* ctable) : 468 SkMallocPixelRef(info, wrappedPixelRef.getAddr(), rowBytes, ctable, false), 469 fWrappedPixelRef(wrappedPixelRef.fWrappedPixelRef ? 470 wrappedPixelRef.fWrappedPixelRef : &wrappedPixelRef) 471{ 472 SkASSERT(fWrappedPixelRef); 473 SkSafeRef(fWrappedPixelRef); 474 475 // don't need to initialize these, as all the relevant logic delegates to the wrapped ref 476 fStorageObj = NULL; 477 fHasGlobalRef = false; 478 fGlobalRefCnt = 0; 479 fOnJavaHeap = false; 480} 481 482AndroidPixelRef::~AndroidPixelRef() { 483 if (fWrappedPixelRef) { 484 SkSafeUnref(fWrappedPixelRef); 485 } else if (fOnJavaHeap) { 486 JNIEnv* env = vm2env(fVM); 487 488 if (fStorageObj && fHasGlobalRef) { 489 env->DeleteGlobalRef(fStorageObj); 490 } 491 fStorageObj = NULL; 492 } 493} 494jbyteArray AndroidPixelRef::getStorageObj() { 495 if (fWrappedPixelRef) { 496 return fWrappedPixelRef->fStorageObj; 497 } 498 return fStorageObj; 499} 500 501void AndroidPixelRef::setLocalJNIRef(jbyteArray arr) { 502 if (fWrappedPixelRef) { 503 // delegate java obj management to the wrapped ref 504 fWrappedPixelRef->setLocalJNIRef(arr); 505 } else if (!fHasGlobalRef) { 506 fStorageObj = arr; 507 } 508} 509 510void AndroidPixelRef::globalRef(void* localref) { 511 if (fWrappedPixelRef) { 512 // delegate java obj management to the wrapped ref 513 fWrappedPixelRef->globalRef(localref); 514 515 // Note: we only ref and unref the wrapped AndroidPixelRef so that 516 // bitmap->pixelRef()->globalRef() and globalUnref() can be used in a pair, even if 517 // the bitmap has its underlying AndroidPixelRef swapped out/wrapped 518 return; 519 } 520 if (fOnJavaHeap && sk_atomic_inc(&fGlobalRefCnt) == 0) { 521 JNIEnv *env = vm2env(fVM); 522 523 // If JNI ref was passed, it is always used 524 if (localref) fStorageObj = (jbyteArray) localref; 525 526 if (fStorageObj == NULL) { 527 SkDebugf("No valid local ref to create a JNI global ref\n"); 528 sk_throw(); 529 } 530 if (fHasGlobalRef) { 531 // This should never happen 532 SkDebugf("Already holding a JNI global ref"); 533 sk_throw(); 534 } 535 536 fStorageObj = (jbyteArray) env->NewGlobalRef(fStorageObj); 537 // TODO: Check for failure here 538 fHasGlobalRef = true; 539 } 540 ref(); 541} 542 543void AndroidPixelRef::globalUnref() { 544 if (fWrappedPixelRef) { 545 // delegate java obj management to the wrapped ref 546 fWrappedPixelRef->globalUnref(); 547 return; 548 } 549 if (fOnJavaHeap && sk_atomic_dec(&fGlobalRefCnt) == 1) { 550 JNIEnv *env = vm2env(fVM); 551 if (!fHasGlobalRef) { 552 SkDebugf("We don't have a global ref!"); 553 sk_throw(); 554 } 555 env->DeleteGlobalRef(fStorageObj); 556 fStorageObj = NULL; 557 fHasGlobalRef = false; 558 } 559 unref(); 560} 561 562/////////////////////////////////////////////////////////////////////////////// 563 564jbyteArray GraphicsJNI::allocateJavaPixelRef(JNIEnv* env, SkBitmap* bitmap, 565 SkColorTable* ctable) { 566 Sk64 size64 = bitmap->getSize64(); 567 if (size64.isNeg() || !size64.is32()) { 568 jniThrowException(env, "java/lang/IllegalArgumentException", 569 "bitmap size exceeds 32bits"); 570 return NULL; 571 } 572 573 SkImageInfo bitmapInfo; 574 if (!bitmap->asImageInfo(&bitmapInfo)) { 575 jniThrowException(env, "java/lang/IllegalArgumentException", 576 "unknown bitmap configuration"); 577 return NULL; 578 } 579 580 size_t size = size64.get32(); 581 jbyteArray arrayObj = (jbyteArray) env->CallObjectMethod(gVMRuntime, 582 gVMRuntime_newNonMovableArray, 583 gByte_class, size); 584 if (env->ExceptionCheck() != 0) { 585 return NULL; 586 } 587 SkASSERT(arrayObj); 588 jbyte* addr = (jbyte*) env->CallLongMethod(gVMRuntime, gVMRuntime_addressOf, arrayObj); 589 if (env->ExceptionCheck() != 0) { 590 return NULL; 591 } 592 SkASSERT(addr); 593 SkPixelRef* pr = new AndroidPixelRef(env, bitmapInfo, (void*) addr, 594 bitmap->rowBytes(), arrayObj, ctable); 595 bitmap->setPixelRef(pr)->unref(); 596 // since we're already allocated, we lockPixels right away 597 // HeapAllocator behaves this way too 598 bitmap->lockPixels(); 599 600 return arrayObj; 601} 602 603/////////////////////////////////////////////////////////////////////////////// 604 605JavaPixelAllocator::JavaPixelAllocator(JNIEnv* env) 606 : fStorageObj(NULL), 607 fAllocCount(0) { 608 if (env->GetJavaVM(&fVM) != JNI_OK) { 609 SkDebugf("------ [%p] env->GetJavaVM failed\n", env); 610 sk_throw(); 611 } 612} 613 614bool JavaPixelAllocator::allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable) { 615 JNIEnv* env = vm2env(fVM); 616 617 fStorageObj = GraphicsJNI::allocateJavaPixelRef(env, bitmap, ctable); 618 fAllocCount += 1; 619 return fStorageObj != NULL; 620} 621 622//////////////////////////////////////////////////////////////////////////////// 623 624JavaHeapBitmapRef::JavaHeapBitmapRef(JNIEnv* env, SkBitmap* nativeBitmap, jbyteArray buffer) { 625 fEnv = env; 626 fNativeBitmap = nativeBitmap; 627 fBuffer = buffer; 628 629 // If the buffer is NULL, the backing memory wasn't allocated on the Java heap 630 if (fBuffer) { 631 ((AndroidPixelRef*) fNativeBitmap->pixelRef())->setLocalJNIRef(fBuffer); 632 } 633} 634 635JavaHeapBitmapRef::~JavaHeapBitmapRef() { 636 if (fBuffer) { 637 ((AndroidPixelRef*) fNativeBitmap->pixelRef())->setLocalJNIRef(NULL); 638 } 639} 640 641//////////////////////////////////////////////////////////////////////////////// 642 643static jclass make_globalref(JNIEnv* env, const char classname[]) 644{ 645 jclass c = env->FindClass(classname); 646 SkASSERT(c); 647 return (jclass) env->NewGlobalRef(c); 648} 649 650static jfieldID getFieldIDCheck(JNIEnv* env, jclass clazz, 651 const char fieldname[], const char type[]) 652{ 653 jfieldID id = env->GetFieldID(clazz, fieldname, type); 654 SkASSERT(id); 655 return id; 656} 657 658int register_android_graphics_Graphics(JNIEnv* env) 659{ 660 jmethodID m; 661 jclass c; 662 663 gRect_class = make_globalref(env, "android/graphics/Rect"); 664 gRect_leftFieldID = getFieldIDCheck(env, gRect_class, "left", "I"); 665 gRect_topFieldID = getFieldIDCheck(env, gRect_class, "top", "I"); 666 gRect_rightFieldID = getFieldIDCheck(env, gRect_class, "right", "I"); 667 gRect_bottomFieldID = getFieldIDCheck(env, gRect_class, "bottom", "I"); 668 669 gRectF_class = make_globalref(env, "android/graphics/RectF"); 670 gRectF_leftFieldID = getFieldIDCheck(env, gRectF_class, "left", "F"); 671 gRectF_topFieldID = getFieldIDCheck(env, gRectF_class, "top", "F"); 672 gRectF_rightFieldID = getFieldIDCheck(env, gRectF_class, "right", "F"); 673 gRectF_bottomFieldID = getFieldIDCheck(env, gRectF_class, "bottom", "F"); 674 675 gPoint_class = make_globalref(env, "android/graphics/Point"); 676 gPoint_xFieldID = getFieldIDCheck(env, gPoint_class, "x", "I"); 677 gPoint_yFieldID = getFieldIDCheck(env, gPoint_class, "y", "I"); 678 679 gPointF_class = make_globalref(env, "android/graphics/PointF"); 680 gPointF_xFieldID = getFieldIDCheck(env, gPointF_class, "x", "F"); 681 gPointF_yFieldID = getFieldIDCheck(env, gPointF_class, "y", "F"); 682 683 gBitmap_class = make_globalref(env, "android/graphics/Bitmap"); 684 gBitmap_nativeInstanceID = getFieldIDCheck(env, gBitmap_class, "mNativeBitmap", "J"); 685 gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>", "(J[BIIIZZ[B[I)V"); 686 gBitmap_reinitMethodID = env->GetMethodID(gBitmap_class, "reinit", "(IIZ)V"); 687 gBitmap_getAllocationByteCountMethodID = env->GetMethodID(gBitmap_class, "getAllocationByteCount", "()I"); 688 gBitmapRegionDecoder_class = make_globalref(env, "android/graphics/BitmapRegionDecoder"); 689 gBitmapRegionDecoder_constructorMethodID = env->GetMethodID(gBitmapRegionDecoder_class, "<init>", "(J)V"); 690 691 gBitmapConfig_class = make_globalref(env, "android/graphics/Bitmap$Config"); 692 gBitmapConfig_nativeInstanceID = getFieldIDCheck(env, gBitmapConfig_class, 693 "nativeInt", "I"); 694 695 gCanvas_class = make_globalref(env, "android/graphics/Canvas"); 696 gCanvas_nativeInstanceID = getFieldIDCheck(env, gCanvas_class, "mNativeCanvas", "J"); 697 698 gPaint_class = make_globalref(env, "android/graphics/Paint"); 699 gPaint_nativeInstanceID = getFieldIDCheck(env, gPaint_class, "mNativePaint", "J"); 700 701 gPicture_class = make_globalref(env, "android/graphics/Picture"); 702 gPicture_nativeInstanceID = getFieldIDCheck(env, gPicture_class, "mNativePicture", "J"); 703 704 gRegion_class = make_globalref(env, "android/graphics/Region"); 705 gRegion_nativeInstanceID = getFieldIDCheck(env, gRegion_class, "mNativeRegion", "J"); 706 gRegion_constructorMethodID = env->GetMethodID(gRegion_class, "<init>", 707 "(JI)V"); 708 709 c = env->FindClass("java/lang/Byte"); 710 gByte_class = (jclass) env->NewGlobalRef( 711 env->GetStaticObjectField(c, env->GetStaticFieldID(c, "TYPE", "Ljava/lang/Class;"))); 712 713 gVMRuntime_class = make_globalref(env, "dalvik/system/VMRuntime"); 714 m = env->GetStaticMethodID(gVMRuntime_class, "getRuntime", "()Ldalvik/system/VMRuntime;"); 715 gVMRuntime = env->NewGlobalRef(env->CallStaticObjectMethod(gVMRuntime_class, m)); 716 gVMRuntime_newNonMovableArray = env->GetMethodID(gVMRuntime_class, "newNonMovableArray", 717 "(Ljava/lang/Class;I)Ljava/lang/Object;"); 718 gVMRuntime_addressOf = env->GetMethodID(gVMRuntime_class, "addressOf", "(Ljava/lang/Object;)J"); 719 720 return 0; 721} 722