/* * Copyright (C) 2006-2007 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 * * 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 * limitations under the License. */ #include "jni.h" #include "GraphicsJNI.h" #include #include "SkCanvas.h" #include "SkDevice.h" #include "SkGLCanvas.h" #include "SkGraphics.h" #include "SkImageRef_GlobalPool.h" #include "SkPorterDuff.h" #include "SkShader.h" #include "SkTemplates.h" #include "SkBoundaryPatch.h" #include "SkMeshUtils.h" #define TIME_DRAWx static uint32_t get_thread_msec() { #if defined(HAVE_POSIX_CLOCKS) struct timespec tm; clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tm); return tm.tv_sec * 1000LL + tm.tv_nsec / 1000000; #else struct timeval tv; gettimeofday(&tv, NULL); return tv.tv_sec * 1000LL + tv.tv_usec / 1000; #endif } namespace android { class SkCanvasGlue { public: static void finalizer(JNIEnv* env, jobject clazz, SkCanvas* canvas) { canvas->unref(); } static SkCanvas* initRaster(JNIEnv* env, jobject, SkBitmap* bitmap) { return bitmap ? new SkCanvas(*bitmap) : new SkCanvas; } static SkCanvas* initGL(JNIEnv* env, jobject) { return new SkGLCanvas; } static void freeCaches(JNIEnv* env, jobject) { // these are called in no particular order SkGLCanvas::DeleteAllTextures(); SkImageRef_GlobalPool::SetRAMUsed(0); SkGraphics::SetFontCacheUsed(0); } static jboolean isOpaque(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); /* Currently we cannot support transparency in GL-based canvas' at the view level. Therefore we cannot base our answer on the device's bitmap, but need to hard-code the answer. If we relax this limitation in views, we can simplify the following code as well. Use the getViewport() call to find out if we're gl-based... */ if (canvas->getViewport(NULL)) { return true; } // normal technique, rely on the device's bitmap for the answer return canvas->getDevice()->accessBitmap(false).isOpaque(); } static int getWidth(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); return canvas->getDevice()->accessBitmap(false).width(); } static int getHeight(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); return canvas->getDevice()->accessBitmap(false).height(); } static void setViewport(JNIEnv* env, jobject, SkCanvas* canvas, int width, int height) { canvas->setViewport(width, height); } static void setBitmap(JNIEnv* env, jobject, SkCanvas* canvas, SkBitmap* bitmap) { canvas->setBitmapDevice(*bitmap); } static int saveAll(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(); } static int save(JNIEnv* env, jobject jcanvas, SkCanvas::SaveFlags flags) { NPE_CHECK_RETURN_ZERO(env, jcanvas); return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags); } static int saveLayer(JNIEnv* env, jobject, SkCanvas* canvas, jobject bounds, SkPaint* paint, int flags) { SkRect* bounds_ = NULL; SkRect storage; if (bounds != NULL) { GraphicsJNI::jrectf_to_rect(env, bounds, &storage); bounds_ = &storage; } return canvas->saveLayer(bounds_, paint, (SkCanvas::SaveFlags)flags); } static int saveLayer4F(JNIEnv* env, jobject, SkCanvas* canvas, jfloat l, jfloat t, jfloat r, jfloat b, SkPaint* paint, int flags) { SkRect bounds; bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r), SkFloatToScalar(b)); return canvas->saveLayer(&bounds, paint, (SkCanvas::SaveFlags)flags); } static int saveLayerAlpha(JNIEnv* env, jobject, SkCanvas* canvas, jobject bounds, int alpha, int flags) { SkRect* bounds_ = NULL; SkRect storage; if (bounds != NULL) { GraphicsJNI::jrectf_to_rect(env, bounds, &storage); bounds_ = &storage; } return canvas->saveLayerAlpha(bounds_, alpha, (SkCanvas::SaveFlags)flags); } static int saveLayerAlpha4F(JNIEnv* env, jobject, SkCanvas* canvas, jfloat l, jfloat t, jfloat r, jfloat b, int alpha, int flags) { SkRect bounds; bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r), SkFloatToScalar(b)); return canvas->saveLayerAlpha(&bounds, alpha, (SkCanvas::SaveFlags)flags); } static void restore(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); if (canvas->getSaveCount() <= 1) { // cannot restore anymore doThrowISE(env, "Underflow in restore"); return; } canvas->restore(); } static int getSaveCount(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); return GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount(); } static void restoreToCount(JNIEnv* env, jobject jcanvas, int restoreCount) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); if (restoreCount < 1) { doThrowIAE(env, "Underflow in restoreToCount"); return; } canvas->restoreToCount(restoreCount); } static void translate(JNIEnv* env, jobject jcanvas, jfloat dx, jfloat dy) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->translate(dx_, dy_); } static void scale__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->scale(sx_, sy_); } static void rotate__F(JNIEnv* env, jobject jcanvas, jfloat degrees) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar degrees_ = SkFloatToScalar(degrees); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->rotate(degrees_); } static void skew__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->skew(sx_, sy_); } static void concat(JNIEnv* env, jobject, SkCanvas* canvas, const SkMatrix* matrix) { canvas->concat(*matrix); } static void setMatrix(JNIEnv* env, jobject, SkCanvas* canvas, const SkMatrix* matrix) { if (NULL == matrix) { canvas->resetMatrix(); } else { canvas->setMatrix(*matrix); } } static jboolean clipRect_FFFF(JNIEnv* env, jobject jcanvas, jfloat left, jfloat top, jfloat right, jfloat bottom) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkRect r; r.set(SkFloatToScalar(left), SkFloatToScalar(top), SkFloatToScalar(right), SkFloatToScalar(bottom)); SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); return c->clipRect(r); } static jboolean clipRect_IIII(JNIEnv* env, jobject jcanvas, jint left, jint top, jint right, jint bottom) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkRect r; r.set(SkIntToScalar(left), SkIntToScalar(top), SkIntToScalar(right), SkIntToScalar(bottom)); return GraphicsJNI::getNativeCanvas(env, jcanvas)->clipRect(r); } static jboolean clipRect_RectF(JNIEnv* env, jobject jcanvas, jobject rectf) { NPE_CHECK_RETURN_ZERO(env, jcanvas); NPE_CHECK_RETURN_ZERO(env, rectf); SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); SkRect tmp; return c->clipRect(*GraphicsJNI::jrectf_to_rect(env, rectf, &tmp)); } static jboolean clipRect_Rect(JNIEnv* env, jobject jcanvas, jobject rect) { NPE_CHECK_RETURN_ZERO(env, jcanvas); NPE_CHECK_RETURN_ZERO(env, rect); SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); SkRect tmp; return c->clipRect(*GraphicsJNI::jrect_to_rect(env, rect, &tmp)); } static jboolean clipRect(JNIEnv* env, jobject, SkCanvas* canvas, float left, float top, float right, float bottom, int op) { SkRect rect; rect.set(SkFloatToScalar(left), SkFloatToScalar(top), SkFloatToScalar(right), SkFloatToScalar(bottom)); return canvas->clipRect(rect, (SkRegion::Op)op); } static jboolean clipPath(JNIEnv* env, jobject, SkCanvas* canvas, SkPath* path, int op) { return canvas->clipPath(*path, (SkRegion::Op)op); } static jboolean clipRegion(JNIEnv* env, jobject, SkCanvas* canvas, SkRegion* deviceRgn, int op) { return canvas->clipRegion(*deviceRgn, (SkRegion::Op)op); } static void setDrawFilter(JNIEnv* env, jobject, SkCanvas* canvas, SkDrawFilter* filter) { canvas->setDrawFilter(filter); } static jboolean quickReject__RectFI(JNIEnv* env, jobject, SkCanvas* canvas, jobject rect, int edgetype) { SkRect rect_; GraphicsJNI::jrectf_to_rect(env, rect, &rect_); return canvas->quickReject(rect_, (SkCanvas::EdgeType)edgetype); } static jboolean quickReject__PathI(JNIEnv* env, jobject, SkCanvas* canvas, SkPath* path, int edgetype) { return canvas->quickReject(*path, (SkCanvas::EdgeType)edgetype); } static jboolean quickReject__FFFFI(JNIEnv* env, jobject, SkCanvas* canvas, jfloat left, jfloat top, jfloat right, jfloat bottom, int edgetype) { SkRect r; r.set(SkFloatToScalar(left), SkFloatToScalar(top), SkFloatToScalar(right), SkFloatToScalar(bottom)); return canvas->quickReject(r, (SkCanvas::EdgeType)edgetype); } static void drawRGB(JNIEnv* env, jobject, SkCanvas* canvas, jint r, jint g, jint b) { canvas->drawARGB(0xFF, r, g, b); } static void drawARGB(JNIEnv* env, jobject, SkCanvas* canvas, jint a, jint r, jint g, jint b) { canvas->drawARGB(a, r, g, b); } static void drawColor__I(JNIEnv* env, jobject, SkCanvas* canvas, jint color) { canvas->drawColor(color); } static void drawColor__II(JNIEnv* env, jobject, SkCanvas* canvas, jint color, SkPorterDuff::Mode mode) { canvas->drawColor(color, SkPorterDuff::ToXfermodeMode(mode)); } static void drawPaint(JNIEnv* env, jobject, SkCanvas* canvas, SkPaint* paint) { canvas->drawPaint(*paint); } static void doPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, jint offset, jint count, jobject jpaint, SkCanvas::PointMode mode) { NPE_CHECK_RETURN_VOID(env, jcanvas); NPE_CHECK_RETURN_VOID(env, jptsArray); NPE_CHECK_RETURN_VOID(env, jpaint); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint); AutoJavaFloatArray autoPts(env, jptsArray); float* floats = autoPts.ptr(); const int length = autoPts.length(); if ((offset | count) < 0 || offset + count > length) { doThrowAIOOBE(env); return; } // now convert the floats into SkPoints count >>= 1; // now it is the number of points SkAutoSTMalloc<32, SkPoint> storage(count); SkPoint* pts = storage.get(); const float* src = floats + offset; for (int i = 0; i < count; i++) { pts[i].set(SkFloatToScalar(src[0]), SkFloatToScalar(src[1])); src += 2; } canvas->drawPoints(mode, count, pts, paint); } static void drawPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, jint offset, jint count, jobject jpaint) { doPoints(env, jcanvas, jptsArray, offset, count, jpaint, SkCanvas::kPoints_PointMode); } static void drawLines(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, jint offset, jint count, jobject jpaint) { doPoints(env, jcanvas, jptsArray, offset, count, jpaint, SkCanvas::kLines_PointMode); } static void drawPoint(JNIEnv* env, jobject jcanvas, float x, float y, jobject jpaint) { NPE_CHECK_RETURN_VOID(env, jcanvas); NPE_CHECK_RETURN_VOID(env, jpaint); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint); canvas->drawPoint(SkFloatToScalar(x), SkFloatToScalar(y), paint); } static void drawLine__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, jfloat startX, jfloat startY, jfloat stopX, jfloat stopY, SkPaint* paint) { canvas->drawLine(SkFloatToScalar(startX), SkFloatToScalar(startY), SkFloatToScalar(stopX), SkFloatToScalar(stopY), *paint); } static void drawRect__RectFPaint(JNIEnv* env, jobject, SkCanvas* canvas, jobject rect, SkPaint* paint) { SkRect rect_; GraphicsJNI::jrectf_to_rect(env, rect, &rect_); canvas->drawRect(rect_, *paint); } static void drawRect__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, jfloat left, jfloat top, jfloat right, jfloat bottom, SkPaint* paint) { SkScalar left_ = SkFloatToScalar(left); SkScalar top_ = SkFloatToScalar(top); SkScalar right_ = SkFloatToScalar(right); SkScalar bottom_ = SkFloatToScalar(bottom); canvas->drawRectCoords(left_, top_, right_, bottom_, *paint); } static void drawOval(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval, SkPaint* paint) { SkRect oval; GraphicsJNI::jrectf_to_rect(env, joval, &oval); canvas->drawOval(oval, *paint); } static void drawCircle(JNIEnv* env, jobject, SkCanvas* canvas, jfloat cx, jfloat cy, jfloat radius, SkPaint* paint) { canvas->drawCircle(SkFloatToScalar(cx), SkFloatToScalar(cy), SkFloatToScalar(radius), *paint); } static void drawArc(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval, jfloat startAngle, jfloat sweepAngle, jboolean useCenter, SkPaint* paint) { SkRect oval; GraphicsJNI::jrectf_to_rect(env, joval, &oval); canvas->drawArc(oval, SkFloatToScalar(startAngle), SkFloatToScalar(sweepAngle), useCenter, *paint); } static void drawRoundRect(JNIEnv* env, jobject, SkCanvas* canvas, jobject jrect, jfloat rx, jfloat ry, SkPaint* paint) { SkRect rect; GraphicsJNI::jrectf_to_rect(env, jrect, &rect); canvas->drawRoundRect(rect, SkFloatToScalar(rx), SkFloatToScalar(ry), *paint); } static void drawPath(JNIEnv* env, jobject, SkCanvas* canvas, SkPath* path, SkPaint* paint) { canvas->drawPath(*path, *paint); } static void drawPicture(JNIEnv* env, jobject, SkCanvas* canvas, SkPicture* picture) { SkASSERT(canvas); SkASSERT(picture); #ifdef TIME_DRAW SkMSec now = get_thread_msec(); //SkTime::GetMSecs(); #endif canvas->drawPicture(*picture); #ifdef TIME_DRAW LOGD("---- picture playback %d ms\n", get_thread_msec() - now); #endif } static void drawBitmap__BitmapFFPaint(JNIEnv* env, jobject jcanvas, SkCanvas* canvas, SkBitmap* bitmap, jfloat left, jfloat top, SkPaint* paint, jint canvasDensity, jint screenDensity, jint bitmapDensity) { SkScalar left_ = SkFloatToScalar(left); SkScalar top_ = SkFloatToScalar(top); if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) { if (screenDensity != 0 && screenDensity != bitmapDensity) { SkPaint filteredPaint; if (paint) { filteredPaint = *paint; } filteredPaint.setFilterBitmap(true); canvas->drawBitmap(*bitmap, left_, top_, &filteredPaint); } else { canvas->drawBitmap(*bitmap, left_, top_, paint); } } else { canvas->save(); SkScalar scale = SkFloatToScalar(canvasDensity / (float)bitmapDensity); canvas->translate(left_, top_); canvas->scale(scale, scale); SkPaint filteredPaint; if (paint) { filteredPaint = *paint; } filteredPaint.setFilterBitmap(true); canvas->drawBitmap(*bitmap, 0, 0, &filteredPaint); canvas->restore(); } } static void doDrawBitmap(JNIEnv* env, SkCanvas* canvas, SkBitmap* bitmap, jobject srcIRect, const SkRect& dst, SkPaint* paint, jint screenDensity, jint bitmapDensity) { SkIRect src, *srcPtr = NULL; if (NULL != srcIRect) { GraphicsJNI::jrect_to_irect(env, srcIRect, &src); srcPtr = &src; } if (screenDensity != 0 && screenDensity != bitmapDensity) { SkPaint filteredPaint; if (paint) { filteredPaint = *paint; } filteredPaint.setFilterBitmap(true); canvas->drawBitmapRect(*bitmap, srcPtr, dst, &filteredPaint); } else { canvas->drawBitmapRect(*bitmap, srcPtr, dst, paint); } } static void drawBitmapRF(JNIEnv* env, jobject, SkCanvas* canvas, SkBitmap* bitmap, jobject srcIRect, jobject dstRectF, SkPaint* paint, jint screenDensity, jint bitmapDensity) { SkRect dst; GraphicsJNI::jrectf_to_rect(env, dstRectF, &dst); doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint, screenDensity, bitmapDensity); } static void drawBitmapRR(JNIEnv* env, jobject, SkCanvas* canvas, SkBitmap* bitmap, jobject srcIRect, jobject dstRect, SkPaint* paint, jint screenDensity, jint bitmapDensity) { SkRect dst; GraphicsJNI::jrect_to_rect(env, dstRect, &dst); doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint, screenDensity, bitmapDensity); } static void drawBitmapArray(JNIEnv* env, jobject, SkCanvas* canvas, jintArray jcolors, int offset, int stride, jfloat x, jfloat y, int width, int height, jboolean hasAlpha, SkPaint* paint) { SkBitmap bitmap; bitmap.setConfig(hasAlpha ? SkBitmap::kARGB_8888_Config : SkBitmap::kRGB_565_Config, width, height); if (!bitmap.allocPixels()) { return; } if (!GraphicsJNI::SetPixels(env, jcolors, offset, stride, 0, 0, width, height, bitmap)) { return; } canvas->drawBitmap(bitmap, SkFloatToScalar(x), SkFloatToScalar(y), paint); } static void drawBitmapMatrix(JNIEnv* env, jobject, SkCanvas* canvas, const SkBitmap* bitmap, const SkMatrix* matrix, const SkPaint* paint) { canvas->drawBitmapMatrix(*bitmap, *matrix, paint); } static void drawBitmapMesh(JNIEnv* env, jobject, SkCanvas* canvas, const SkBitmap* bitmap, int meshWidth, int meshHeight, jfloatArray jverts, int vertIndex, jintArray jcolors, int colorIndex, const SkPaint* paint) { const int ptCount = (meshWidth + 1) * (meshHeight + 1); const int indexCount = meshWidth * meshHeight * 6; AutoJavaFloatArray vertA(env, jverts, vertIndex + (ptCount << 1)); AutoJavaIntArray colorA(env, jcolors, colorIndex + ptCount); /* Our temp storage holds 2 or 3 arrays. texture points [ptCount * sizeof(SkPoint)] optionally vertex points [ptCount * sizeof(SkPoint)] if we need a copy to convert from float to fixed indices [ptCount * sizeof(uint16_t)] */ ssize_t storageSize = ptCount * sizeof(SkPoint); // texs[] #ifdef SK_SCALAR_IS_FIXED storageSize += ptCount * sizeof(SkPoint); // storage for verts #endif storageSize += indexCount * sizeof(uint16_t); // indices[] SkAutoMalloc storage(storageSize); SkPoint* texs = (SkPoint*)storage.get(); SkPoint* verts; uint16_t* indices; #ifdef SK_SCALAR_IS_FLOAT verts = (SkPoint*)(vertA.ptr() + vertIndex); indices = (uint16_t*)(texs + ptCount); #else verts = texs + ptCount; indices = (uint16_t*)(verts + ptCount); // convert floats to fixed { const float* src = vertA.ptr() + vertIndex; for (int i = 0; i < ptCount; i++) { verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1])); src += 2; } } #endif // cons up texture coordinates and indices { const SkScalar w = SkIntToScalar(bitmap->width()); const SkScalar h = SkIntToScalar(bitmap->height()); const SkScalar dx = w / meshWidth; const SkScalar dy = h / meshHeight; SkPoint* texsPtr = texs; SkScalar y = 0; for (int i = 0; i <= meshHeight; i++) { if (i == meshHeight) { y = h; // to ensure numerically we hit h exactly } SkScalar x = 0; for (int j = 0; j < meshWidth; j++) { texsPtr->set(x, y); texsPtr += 1; x += dx; } texsPtr->set(w, y); texsPtr += 1; y += dy; } SkASSERT(texsPtr - texs == ptCount); } // cons up indices { uint16_t* indexPtr = indices; int index = 0; for (int i = 0; i < meshHeight; i++) { for (int j = 0; j < meshWidth; j++) { // lower-left triangle *indexPtr++ = index; *indexPtr++ = index + meshWidth + 1; *indexPtr++ = index + meshWidth + 2; // upper-right triangle *indexPtr++ = index; *indexPtr++ = index + meshWidth + 2; *indexPtr++ = index + 1; // bump to the next cell index += 1; } // bump to the next row index += 1; } SkASSERT(indexPtr - indices == indexCount); SkASSERT((char*)indexPtr - (char*)storage.get() == storageSize); } // double-check that we have legal indices #ifdef SK_DEBUG { for (int i = 0; i < indexCount; i++) { SkASSERT((unsigned)indices[i] < (unsigned)ptCount); } } #endif // cons-up a shader for the bitmap SkPaint tmpPaint; if (paint) { tmpPaint = *paint; } SkShader* shader = SkShader::CreateBitmapShader(*bitmap, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode); tmpPaint.setShader(shader)->safeUnref(); canvas->drawVertices(SkCanvas::kTriangles_VertexMode, ptCount, verts, texs, (const SkColor*)colorA.ptr(), NULL, indices, indexCount, tmpPaint); } static void drawVertices(JNIEnv* env, jobject, SkCanvas* canvas, SkCanvas::VertexMode mode, int vertexCount, jfloatArray jverts, int vertIndex, jfloatArray jtexs, int texIndex, jintArray jcolors, int colorIndex, jshortArray jindices, int indexIndex, int indexCount, const SkPaint* paint) { AutoJavaFloatArray vertA(env, jverts, vertIndex + vertexCount); AutoJavaFloatArray texA(env, jtexs, texIndex + vertexCount); AutoJavaIntArray colorA(env, jcolors, colorIndex + vertexCount); AutoJavaShortArray indexA(env, jindices, indexIndex + indexCount); const int ptCount = vertexCount >> 1; SkPoint* verts; SkPoint* texs = NULL; #ifdef SK_SCALAR_IS_FLOAT verts = (SkPoint*)(vertA.ptr() + vertIndex); if (jtexs != NULL) { texs = (SkPoint*)(texA.ptr() + texIndex); } #else int count = ptCount; // for verts if (jtexs != NULL) { count += ptCount; // += for texs } SkAutoMalloc storage(count * sizeof(SkPoint)); verts = (SkPoint*)storage.get(); const float* src = vertA.ptr() + vertIndex; for (int i = 0; i < ptCount; i++) { verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1])); src += 2; } if (jtexs != NULL) { texs = verts + ptCount; src = texA.ptr() + texIndex; for (int i = 0; i < ptCount; i++) { texs[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1])); src += 2; } } #endif const SkColor* colors = NULL; const uint16_t* indices = NULL; if (jcolors != NULL) { colors = (const SkColor*)(colorA.ptr() + colorIndex); } if (jindices != NULL) { indices = (const uint16_t*)(indexA.ptr() + indexIndex); } canvas->drawVertices(mode, ptCount, verts, texs, colors, NULL, indices, indexCount, *paint); } static void drawText___CIIFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, jcharArray text, int index, int count, jfloat x, jfloat y, SkPaint* paint) { jchar* textArray = env->GetCharArrayElements(text, NULL); jsize textCount = env->GetArrayLength(text); SkScalar x_ = SkFloatToScalar(x); SkScalar y_ = SkFloatToScalar(y); canvas->drawText(textArray + index, count << 1, x_, y_, *paint); env->ReleaseCharArrayElements(text, textArray, 0); } static void drawText__StringIIFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, jstring text, int start, int end, jfloat x, jfloat y, SkPaint* paint) { const void* text_ = env->GetStringChars(text, NULL); SkScalar x_ = SkFloatToScalar(x); SkScalar y_ = SkFloatToScalar(y); canvas->drawText((const uint16_t*)text_ + start, (end - start) << 1, x_, y_, *paint); env->ReleaseStringChars(text, (const jchar*) text_); } static void drawString(JNIEnv* env, jobject canvas, jstring text, jfloat x, jfloat y, jobject paint) { NPE_CHECK_RETURN_VOID(env, canvas); NPE_CHECK_RETURN_VOID(env, paint); NPE_CHECK_RETURN_VOID(env, text); size_t count = env->GetStringLength(text); if (0 == count) { return; } const jchar* text_ = env->GetStringChars(text, NULL); SkCanvas* c = GraphicsJNI::getNativeCanvas(env, canvas); c->drawText(text_, count << 1, SkFloatToScalar(x), SkFloatToScalar(y), *GraphicsJNI::getNativePaint(env, paint)); env->ReleaseStringChars(text, text_); } static void drawPosText___CII_FPaint(JNIEnv* env, jobject, SkCanvas* canvas, jcharArray text, int index, int count, jfloatArray pos, SkPaint* paint) { jchar* textArray = text ? env->GetCharArrayElements(text, NULL) : NULL; jsize textCount = text ? env->GetArrayLength(text) : NULL; float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; int posCount = pos ? env->GetArrayLength(pos) >> 1: 0; SkPoint* posPtr = posCount > 0 ? new SkPoint[posCount] : NULL; int indx; for (indx = 0; indx < posCount; indx++) { posPtr[indx].fX = SkFloatToScalar(posArray[indx << 1]); posPtr[indx].fY = SkFloatToScalar(posArray[(indx << 1) + 1]); } canvas->drawPosText(textArray + index, count << 1, posPtr, *paint); if (text) { env->ReleaseCharArrayElements(text, textArray, 0); } if (pos) { env->ReleaseFloatArrayElements(pos, posArray, 0); } delete[] posPtr; } static void drawPosText__String_FPaint(JNIEnv* env, jobject, SkCanvas* canvas, jstring text, jfloatArray pos, SkPaint* paint) { const void* text_ = text ? env->GetStringChars(text, NULL) : NULL; int byteLength = text ? env->GetStringLength(text) : 0; float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; int posCount = pos ? env->GetArrayLength(pos) >> 1: 0; SkPoint* posPtr = posCount > 0 ? new SkPoint[posCount] : NULL; for (int indx = 0; indx < posCount; indx++) { posPtr[indx].fX = SkFloatToScalar(posArray[indx << 1]); posPtr[indx].fY = SkFloatToScalar(posArray[(indx << 1) + 1]); } canvas->drawPosText(text_, byteLength << 1, posPtr, *paint); if (text) { env->ReleaseStringChars(text, (const jchar*) text_); } if (pos) { env->ReleaseFloatArrayElements(pos, posArray, 0); } delete[] posPtr; } static void drawTextOnPath___CIIPathFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, jcharArray text, int index, int count, SkPath* path, jfloat hOffset, jfloat vOffset, SkPaint* paint) { jchar* textArray = env->GetCharArrayElements(text, NULL); canvas->drawTextOnPathHV(textArray + index, count << 1, *path, SkFloatToScalar(hOffset), SkFloatToScalar(vOffset), *paint); env->ReleaseCharArrayElements(text, textArray, 0); } static void drawTextOnPath__StringPathFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, jstring text, SkPath* path, jfloat hOffset, jfloat vOffset, SkPaint* paint) { const jchar* text_ = env->GetStringChars(text, NULL); int byteLength = env->GetStringLength(text) << 1; canvas->drawTextOnPathHV(text_, byteLength, *path, SkFloatToScalar(hOffset), SkFloatToScalar(vOffset), *paint); env->ReleaseStringChars(text, text_); } static bool getClipBounds(JNIEnv* env, jobject, SkCanvas* canvas, jobject bounds) { SkRect r; SkIRect ir; bool result = canvas->getClipBounds(&r, SkCanvas::kBW_EdgeType); r.round(&ir); (void)GraphicsJNI::irect_to_jrect(ir, env, bounds); return result; } static void getCTM(JNIEnv* env, jobject, SkCanvas* canvas, SkMatrix* matrix) { *matrix = canvas->getTotalMatrix(); } }; static JNINativeMethod gCanvasMethods[] = { {"finalizer", "(I)V", (void*) SkCanvasGlue::finalizer}, {"initRaster","(I)I", (void*) SkCanvasGlue::initRaster}, {"initGL","()I", (void*) SkCanvasGlue::initGL}, {"isOpaque","()Z", (void*) SkCanvasGlue::isOpaque}, {"getWidth","()I", (void*) SkCanvasGlue::getWidth}, {"getHeight","()I", (void*) SkCanvasGlue::getHeight}, {"native_setBitmap","(II)V", (void*) SkCanvasGlue::setBitmap}, {"nativeSetViewport", "(III)V", (void*) SkCanvasGlue::setViewport}, {"save","()I", (void*) SkCanvasGlue::saveAll}, {"save","(I)I", (void*) SkCanvasGlue::save}, {"native_saveLayer","(ILandroid/graphics/RectF;II)I", (void*) SkCanvasGlue::saveLayer}, {"native_saveLayer","(IFFFFII)I", (void*) SkCanvasGlue::saveLayer4F}, {"native_saveLayerAlpha","(ILandroid/graphics/RectF;II)I", (void*) SkCanvasGlue::saveLayerAlpha}, {"native_saveLayerAlpha","(IFFFFII)I", (void*) SkCanvasGlue::saveLayerAlpha4F}, {"restore","()V", (void*) SkCanvasGlue::restore}, {"getSaveCount","()I", (void*) SkCanvasGlue::getSaveCount}, {"restoreToCount","(I)V", (void*) SkCanvasGlue::restoreToCount}, {"translate","(FF)V", (void*) SkCanvasGlue::translate}, {"scale","(FF)V", (void*) SkCanvasGlue::scale__FF}, {"rotate","(F)V", (void*) SkCanvasGlue::rotate__F}, {"skew","(FF)V", (void*) SkCanvasGlue::skew__FF}, {"native_concat","(II)V", (void*) SkCanvasGlue::concat}, {"native_setMatrix","(II)V", (void*) SkCanvasGlue::setMatrix}, {"clipRect","(FFFF)Z", (void*) SkCanvasGlue::clipRect_FFFF}, {"clipRect","(IIII)Z", (void*) SkCanvasGlue::clipRect_IIII}, {"clipRect","(Landroid/graphics/RectF;)Z", (void*) SkCanvasGlue::clipRect_RectF}, {"clipRect","(Landroid/graphics/Rect;)Z", (void*) SkCanvasGlue::clipRect_Rect}, {"native_clipRect","(IFFFFI)Z", (void*) SkCanvasGlue::clipRect}, {"native_clipPath","(III)Z", (void*) SkCanvasGlue::clipPath}, {"native_clipRegion","(III)Z", (void*) SkCanvasGlue::clipRegion}, {"nativeSetDrawFilter", "(II)V", (void*) SkCanvasGlue::setDrawFilter}, {"native_getClipBounds","(ILandroid/graphics/Rect;)Z", (void*) SkCanvasGlue::getClipBounds}, {"native_getCTM", "(II)V", (void*)SkCanvasGlue::getCTM}, {"native_quickReject","(ILandroid/graphics/RectF;I)Z", (void*) SkCanvasGlue::quickReject__RectFI}, {"native_quickReject","(III)Z", (void*) SkCanvasGlue::quickReject__PathI}, {"native_quickReject","(IFFFFI)Z", (void*)SkCanvasGlue::quickReject__FFFFI}, {"native_drawRGB","(IIII)V", (void*) SkCanvasGlue::drawRGB}, {"native_drawARGB","(IIIII)V", (void*) SkCanvasGlue::drawARGB}, {"native_drawColor","(II)V", (void*) SkCanvasGlue::drawColor__I}, {"native_drawColor","(III)V", (void*) SkCanvasGlue::drawColor__II}, {"native_drawPaint","(II)V", (void*) SkCanvasGlue::drawPaint}, {"drawPoint", "(FFLandroid/graphics/Paint;)V", (void*) SkCanvasGlue::drawPoint}, {"drawPoints", "([FIILandroid/graphics/Paint;)V", (void*) SkCanvasGlue::drawPoints}, {"drawLines", "([FIILandroid/graphics/Paint;)V", (void*) SkCanvasGlue::drawLines}, {"native_drawLine","(IFFFFI)V", (void*) SkCanvasGlue::drawLine__FFFFPaint}, {"native_drawRect","(ILandroid/graphics/RectF;I)V", (void*) SkCanvasGlue::drawRect__RectFPaint}, {"native_drawRect","(IFFFFI)V", (void*) SkCanvasGlue::drawRect__FFFFPaint}, {"native_drawOval","(ILandroid/graphics/RectF;I)V", (void*) SkCanvasGlue::drawOval}, {"native_drawCircle","(IFFFI)V", (void*) SkCanvasGlue::drawCircle}, {"native_drawArc","(ILandroid/graphics/RectF;FFZI)V", (void*) SkCanvasGlue::drawArc}, {"native_drawRoundRect","(ILandroid/graphics/RectF;FFI)V", (void*) SkCanvasGlue::drawRoundRect}, {"native_drawPath","(III)V", (void*) SkCanvasGlue::drawPath}, {"native_drawBitmap","(IIFFIIII)V", (void*) SkCanvasGlue::drawBitmap__BitmapFFPaint}, {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/RectF;III)V", (void*) SkCanvasGlue::drawBitmapRF}, {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/Rect;III)V", (void*) SkCanvasGlue::drawBitmapRR}, {"native_drawBitmap", "(I[IIIFFIIZI)V", (void*)SkCanvasGlue::drawBitmapArray}, {"nativeDrawBitmapMatrix", "(IIII)V", (void*)SkCanvasGlue::drawBitmapMatrix}, {"nativeDrawBitmapMesh", "(IIII[FI[III)V", (void*)SkCanvasGlue::drawBitmapMesh}, {"nativeDrawVertices", "(III[FI[FI[II[SIII)V", (void*)SkCanvasGlue::drawVertices}, {"native_drawText","(I[CIIFFI)V", (void*) SkCanvasGlue::drawText___CIIFFPaint}, {"native_drawText","(ILjava/lang/String;IIFFI)V", (void*) SkCanvasGlue::drawText__StringIIFFPaint}, {"drawText","(Ljava/lang/String;FFLandroid/graphics/Paint;)V", (void*) SkCanvasGlue::drawString}, {"native_drawPosText","(I[CII[FI)V", (void*) SkCanvasGlue::drawPosText___CII_FPaint}, {"native_drawPosText","(ILjava/lang/String;[FI)V", (void*) SkCanvasGlue::drawPosText__String_FPaint}, {"native_drawTextOnPath","(I[CIIIFFI)V", (void*) SkCanvasGlue::drawTextOnPath___CIIPathFFPaint}, {"native_drawTextOnPath","(ILjava/lang/String;IFFI)V", (void*) SkCanvasGlue::drawTextOnPath__StringPathFFPaint}, {"native_drawPicture", "(II)V", (void*) SkCanvasGlue::drawPicture}, {"freeCaches", "()V", (void*) SkCanvasGlue::freeCaches} }; /////////////////////////////////////////////////////////////////////////////// static void BoundaryPatch_computeCubic(JNIEnv* env, jobject, jfloatArray jpts, int texW, int texH, int rows, int cols, jfloatArray jverts, jshortArray jidx) { AutoJavaFloatArray ptsArray(env, jpts, 24, kRO_JNIAccess); int vertCount = rows * cols; AutoJavaFloatArray vertsArray(env, jverts, vertCount * 4, kRW_JNIAccess); SkPoint* verts = (SkPoint*)vertsArray.ptr(); SkPoint* texs = verts + vertCount; int idxCount = (rows - 1) * (cols - 1) * 6; AutoJavaShortArray idxArray(env, jidx, idxCount, kRW_JNIAccess); uint16_t* idx = (uint16_t*)idxArray.ptr(); // cast from int16_t* SkCubicBoundary cubic; memcpy(cubic.fPts, ptsArray.ptr(), 12 * sizeof(SkPoint)); SkBoundaryPatch patch; patch.setBoundary(&cubic); // generate our verts patch.evalPatch(verts, rows, cols); SkMeshIndices mesh; // generate our texs and idx mesh.init(texs, idx, texW, texH, rows, cols); } static JNINativeMethod gBoundaryPatchMethods[] = { {"nativeComputeCubicPatch", "([FIIII[F[S)V", (void*)BoundaryPatch_computeCubic }, }; /////////////////////////////////////////////////////////////////////////////// #include #define REG(env, name, array) \ result = android::AndroidRuntime::registerNativeMethods(env, name, array, \ SK_ARRAY_COUNT(array)); \ if (result < 0) return result int register_android_graphics_Canvas(JNIEnv* env) { int result; REG(env, "android/graphics/Canvas", gCanvasMethods); REG(env, "android/graphics/utils/BoundaryPatch", gBoundaryPatchMethods); return result; } }