frameworks/base/core/jni/android/graphics/Canvas.cpp

   1 /*
   2  * Copyright (C) 2006-2007 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "jni.h"
  18 #include "GraphicsJNI.h"
  19 #include <android_runtime/AndroidRuntime.h>
  20
  21 #include "SkCanvas.h"
  22 #include "SkDevice.h"
  23 #include "SkGLCanvas.h"
  24 #include "SkGraphics.h"
  25 #include "SkImageRef_GlobalPool.h"
  26 #include "SkPorterDuff.h"
  27 #include "SkShader.h"
  28 #include "SkTemplates.h"
  29
  30 #include "SkBoundaryPatch.h"
  31 #include "SkMeshUtils.h"
  32
  33 #define TIME_DRAWx
  34
  35 static uint32_t get_thread_msec() {
  36 #if defined(HAVE_POSIX_CLOCKS)
  37     struct timespec tm;
  38
  39     clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tm);
  40
  41     return tm.tv_sec * 1000LL + tm.tv_nsec / 1000000;
  42 #else
  43     struct timeval tv;
  44
  45     gettimeofday(&tv, NULL);
  46     return tv.tv_sec * 1000LL + tv.tv_usec / 1000;
  47 #endif
  48 }
  49
  50 namespace android {
  51
  52 class SkCanvasGlue {
  53 public:
  54
  55     static void finalizer(JNIEnv* env, jobject clazz, SkCanvas* canvas) {
  56         canvas->unref();
  57     }
  58
  59     static SkCanvas* initRaster(JNIEnv* env, jobject, SkBitmap* bitmap) {
  60         return bitmap ? new SkCanvas(*bitmap) : new SkCanvas;
  61     }
  62
  63     static SkCanvas* initGL(JNIEnv* env, jobject) {
  64         return new SkGLCanvas;
  65     }
  66
  67     static void freeCaches(JNIEnv* env, jobject) {
  68         // these are called in no particular order
  69         SkGLCanvas::DeleteAllTextures();
  70         SkImageRef_GlobalPool::SetRAMUsed(0);
  71         SkGraphics::SetFontCacheUsed(0);
  72     }
  73
  74     static jboolean isOpaque(JNIEnv* env, jobject jcanvas) {
  75         NPE_CHECK_RETURN_ZERO(env, jcanvas);
  76         SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
  77
  78         /*
  79             Currently we cannot support transparency in GL-based canvas' at
  80             the view level. Therefore we cannot base our answer on the device's
  81             bitmap, but need to hard-code the answer. If we relax this
  82             limitation in views, we can simplify the following code as well.
  83
  84             Use the getViewport() call to find out if we're gl-based...
  85         */
  86         if (canvas->getViewport(NULL)) {
  87             return true;
  88         }
  89
  90         // normal technique, rely on the device's bitmap for the answer
  91         return canvas->getDevice()->accessBitmap(false).isOpaque();
  92     }
  93
  94     static int getWidth(JNIEnv* env, jobject jcanvas) {
  95         NPE_CHECK_RETURN_ZERO(env, jcanvas);
  96         SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
  97         return canvas->getDevice()->accessBitmap(false).width();
  98     }
  99
 100     static int getHeight(JNIEnv* env, jobject jcanvas) {
 101         NPE_CHECK_RETURN_ZERO(env, jcanvas);
 102         SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
 103         return canvas->getDevice()->accessBitmap(false).height();
 104     }
 105
 106     static void setViewport(JNIEnv* env, jobject, SkCanvas* canvas,
 107                             int width, int height) {
 108         canvas->setViewport(width, height);
 109     }
 110
 111     static void setBitmap(JNIEnv* env, jobject, SkCanvas* canvas,
 112                           SkBitmap* bitmap) {
 113         canvas->setBitmapDevice(*bitmap);
 114     }
 115
 116     static int saveAll(JNIEnv* env, jobject jcanvas) {
 117         NPE_CHECK_RETURN_ZERO(env, jcanvas);
 118         return GraphicsJNI::getNativeCanvas(env, jcanvas)->save();
 119     }
 120
 121     static int save(JNIEnv* env, jobject jcanvas, SkCanvas::SaveFlags flags) {
 122         NPE_CHECK_RETURN_ZERO(env, jcanvas);
 123         return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags);
 124     }
 125
 126     static int saveLayer(JNIEnv* env, jobject, SkCanvas* canvas, jobject bounds,
 127                          SkPaint* paint, int flags) {
 128         SkRect* bounds_ = NULL;
 129         SkRect  storage;
 130         if (bounds != NULL) {
 131             GraphicsJNI::jrectf_to_rect(env, bounds, &storage);
 132             bounds_ = &storage;
 133         }
 134         return canvas->saveLayer(bounds_, paint, (SkCanvas::SaveFlags)flags);
 135     }
 136
 137     static int saveLayer4F(JNIEnv* env, jobject, SkCanvas* canvas,
 138                            jfloat l, jfloat t, jfloat r, jfloat b,
 139                            SkPaint* paint, int flags) {
 140         SkRect bounds;
 141         bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r),
 142                    SkFloatToScalar(b));
 143         return canvas->saveLayer(&bounds, paint, (SkCanvas::SaveFlags)flags);
 144     }
 145
 146     static int saveLayerAlpha(JNIEnv* env, jobject, SkCanvas* canvas,
 147                               jobject bounds, int alpha, int flags) {
 148         SkRect* bounds_ = NULL;
 149         SkRect  storage;
 150         if (bounds != NULL) {
 151             GraphicsJNI::jrectf_to_rect(env, bounds, &storage);
 152             bounds_ = &storage;
 153         }
 154         return canvas->saveLayerAlpha(bounds_, alpha,
 155                                       (SkCanvas::SaveFlags)flags);
 156     }
 157
 158     static int saveLayerAlpha4F(JNIEnv* env, jobject, SkCanvas* canvas,
 159                                 jfloat l, jfloat t, jfloat r, jfloat b,
 160                                 int alpha, int flags) {
 161         SkRect  bounds;
 162         bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r),
 163                    SkFloatToScalar(b));
 164         return canvas->saveLayerAlpha(&bounds, alpha,
 165                                       (SkCanvas::SaveFlags)flags);
 166     }
 167
 168     static void restore(JNIEnv* env, jobject jcanvas) {
 169         NPE_CHECK_RETURN_VOID(env, jcanvas);
 170         SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
 171         if (canvas->getSaveCount() <= 1) {  // cannot restore anymore
 172             doThrowISE(env, "Underflow in restore");
 173             return;
 174         }
 175         canvas->restore();
 176     }
 177
 178     static int getSaveCount(JNIEnv* env, jobject jcanvas) {
 179         NPE_CHECK_RETURN_ZERO(env, jcanvas);
 180         return GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount();
 181     }
 182
 183     static void restoreToCount(JNIEnv* env, jobject jcanvas, int restoreCount) {
 184         NPE_CHECK_RETURN_VOID(env, jcanvas);
 185         SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
 186         if (restoreCount < 1) {
 187             doThrowIAE(env, "Underflow in restoreToCount");
 188             return;
 189         }
 190         canvas->restoreToCount(restoreCount);
 191     }
 192
 193     static void translate(JNIEnv* env, jobject jcanvas, jfloat dx, jfloat dy) {
 194         NPE_CHECK_RETURN_VOID(env, jcanvas);
 195         SkScalar dx_ = SkFloatToScalar(dx);
 196         SkScalar dy_ = SkFloatToScalar(dy);
 197         (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->translate(dx_, dy_);
 198     }
 199
 200     static void scale__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) {
 201         NPE_CHECK_RETURN_VOID(env, jcanvas);
 202         SkScalar sx_ = SkFloatToScalar(sx);
 203         SkScalar sy_ = SkFloatToScalar(sy);
 204         (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->scale(sx_, sy_);
 205     }
 206
 207     static void rotate__F(JNIEnv* env, jobject jcanvas, jfloat degrees) {
 208         NPE_CHECK_RETURN_VOID(env, jcanvas);
 209         SkScalar degrees_ = SkFloatToScalar(degrees);
 210         (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->rotate(degrees_);
 211     }
 212
 213     static void skew__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) {
 214         NPE_CHECK_RETURN_VOID(env, jcanvas);
 215         SkScalar sx_ = SkFloatToScalar(sx);
 216         SkScalar sy_ = SkFloatToScalar(sy);
 217         (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->skew(sx_, sy_);
 218     }
 219
 220     static void concat(JNIEnv* env, jobject, SkCanvas* canvas,
 221                        const SkMatrix* matrix) {
 222         canvas->concat(*matrix);
 223     }
 224
 225     static void setMatrix(JNIEnv* env, jobject, SkCanvas* canvas,
 226                           const SkMatrix* matrix) {
 227         if (NULL == matrix) {
 228             canvas->resetMatrix();
 229         } else {
 230             canvas->setMatrix(*matrix);
 231         }
 232     }
 233
 234     static jboolean clipRect_FFFF(JNIEnv* env, jobject jcanvas, jfloat left,
 235                                   jfloat top, jfloat right, jfloat bottom) {
 236         NPE_CHECK_RETURN_ZERO(env, jcanvas);
 237         SkRect  r;
 238         r.set(SkFloatToScalar(left), SkFloatToScalar(top),
 239               SkFloatToScalar(right), SkFloatToScalar(bottom));
 240         SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas);
 241         return c->clipRect(r);
 242     }
 243
 244     static jboolean clipRect_IIII(JNIEnv* env, jobject jcanvas, jint left,
 245                                   jint top, jint right, jint bottom) {
 246         NPE_CHECK_RETURN_ZERO(env, jcanvas);
 247         SkRect  r;
 248         r.set(SkIntToScalar(left), SkIntToScalar(top),
 249               SkIntToScalar(right), SkIntToScalar(bottom));
 250         return GraphicsJNI::getNativeCanvas(env, jcanvas)->clipRect(r);
 251     }
 252
 253     static jboolean clipRect_RectF(JNIEnv* env, jobject jcanvas, jobject rectf) {
 254         NPE_CHECK_RETURN_ZERO(env, jcanvas);
 255         NPE_CHECK_RETURN_ZERO(env, rectf);
 256         SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas);
 257         SkRect tmp;
 258         return c->clipRect(*GraphicsJNI::jrectf_to_rect(env, rectf, &tmp));
 259     }
 260
 261     static jboolean clipRect_Rect(JNIEnv* env, jobject jcanvas, jobject rect) {
 262         NPE_CHECK_RETURN_ZERO(env, jcanvas);
 263         NPE_CHECK_RETURN_ZERO(env, rect);
 264         SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas);
 265         SkRect tmp;
 266         return c->clipRect(*GraphicsJNI::jrect_to_rect(env, rect, &tmp));
 267     }
 268
 269     static jboolean clipRect(JNIEnv* env, jobject, SkCanvas* canvas,
 270                              float left, float top, float right, float bottom,
 271                              int op) {
 272         SkRect rect;
 273         rect.set(SkFloatToScalar(left), SkFloatToScalar(top),
 274                  SkFloatToScalar(right), SkFloatToScalar(bottom));
 275         return canvas->clipRect(rect, (SkRegion::Op)op);
 276     }
 277
 278     static jboolean clipPath(JNIEnv* env, jobject, SkCanvas* canvas,
 279                              SkPath* path, int op) {
 280         return canvas->clipPath(*path, (SkRegion::Op)op);
 281     }
 282
 283     static jboolean clipRegion(JNIEnv* env, jobject, SkCanvas* canvas,
 284                                SkRegion* deviceRgn, int op) {
 285         return canvas->clipRegion(*deviceRgn, (SkRegion::Op)op);
 286     }
 287
 288     static void setDrawFilter(JNIEnv* env, jobject, SkCanvas* canvas,
 289                               SkDrawFilter* filter) {
 290         canvas->setDrawFilter(filter);
 291     }
 292
 293     static jboolean quickReject__RectFI(JNIEnv* env, jobject, SkCanvas* canvas,
 294                                         jobject rect, int edgetype) {
 295         SkRect rect_;
 296         GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
 297         return canvas->quickReject(rect_, (SkCanvas::EdgeType)edgetype);
 298     }
 299
 300     static jboolean quickReject__PathI(JNIEnv* env, jobject, SkCanvas* canvas,
 301                                        SkPath* path, int edgetype) {
 302         return canvas->quickReject(*path, (SkCanvas::EdgeType)edgetype);
 303     }
 304
 305     static jboolean quickReject__FFFFI(JNIEnv* env, jobject, SkCanvas* canvas,
 306                                        jfloat left, jfloat top, jfloat right,
 307                                        jfloat bottom, int edgetype) {
 308         SkRect r;
 309         r.set(SkFloatToScalar(left), SkFloatToScalar(top),
 310               SkFloatToScalar(right), SkFloatToScalar(bottom));
 311         return canvas->quickReject(r, (SkCanvas::EdgeType)edgetype);
 312     }
 313
 314     static void drawRGB(JNIEnv* env, jobject, SkCanvas* canvas,
 315                         jint r, jint g, jint b) {
 316         canvas->drawARGB(0xFF, r, g, b);
 317     }
 318
 319     static void drawARGB(JNIEnv* env, jobject, SkCanvas* canvas,
 320                          jint a, jint r, jint g, jint b) {
 321         canvas->drawARGB(a, r, g, b);
 322     }
 323
 324     static void drawColor__I(JNIEnv* env, jobject, SkCanvas* canvas,
 325                              jint color) {
 326         canvas->drawColor(color);
 327     }
 328
 329     static void drawColor__II(JNIEnv* env, jobject, SkCanvas* canvas,
 330                               jint color, SkPorterDuff::Mode mode) {
 331         canvas->drawColor(color, SkPorterDuff::ToXfermodeMode(mode));
 332     }
 333
 334     static void drawPaint(JNIEnv* env, jobject, SkCanvas* canvas,
 335                           SkPaint* paint) {
 336         canvas->drawPaint(*paint);
 337     }
 338
 339     static void doPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray,
 340                          jint offset, jint count, jobject jpaint,
 341                          SkCanvas::PointMode mode) {
 342         NPE_CHECK_RETURN_VOID(env, jcanvas);
 343         NPE_CHECK_RETURN_VOID(env, jptsArray);
 344         NPE_CHECK_RETURN_VOID(env, jpaint);
 345         SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
 346         const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint);
 347
 348         AutoJavaFloatArray autoPts(env, jptsArray);
 349         float* floats = autoPts.ptr();
 350         const int length = autoPts.length();
 351
 352         if ((offset | count) < 0 || offset + count > length) {
 353             doThrowAIOOBE(env);
 354             return;
 355         }
 356
 357         // now convert the floats into SkPoints
 358         count >>= 1;    // now it is the number of points
 359         SkAutoSTMalloc<32, SkPoint> storage(count);
 360         SkPoint* pts = storage.get();
 361         const float* src = floats + offset;
 362         for (int i = 0; i < count; i++) {
 363             pts[i].set(SkFloatToScalar(src[0]), SkFloatToScalar(src[1]));
 364             src += 2;
 365         }
 366         canvas->drawPoints(mode, count, pts, paint);
 367     }
 368
 369     static void drawPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray,
 370                            jint offset, jint count, jobject jpaint) {
 371         doPoints(env, jcanvas, jptsArray, offset, count, jpaint,
 372                  SkCanvas::kPoints_PointMode);
 373     }
 374
 375     static void drawLines(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray,
 376                            jint offset, jint count, jobject jpaint) {
 377         doPoints(env, jcanvas, jptsArray, offset, count, jpaint,
 378                  SkCanvas::kLines_PointMode);
 379     }
 380
 381     static void drawPoint(JNIEnv* env, jobject jcanvas, float x, float y,
 382                           jobject jpaint) {
 383         NPE_CHECK_RETURN_VOID(env, jcanvas);
 384         NPE_CHECK_RETURN_VOID(env, jpaint);
 385         SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
 386         const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint);
 387
 388         canvas->drawPoint(SkFloatToScalar(x), SkFloatToScalar(y), paint);
 389     }
 390
 391     static void drawLine__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas,
 392                                     jfloat startX, jfloat startY, jfloat stopX,
 393                                     jfloat stopY, SkPaint* paint) {
 394         canvas->drawLine(SkFloatToScalar(startX), SkFloatToScalar(startY),
 395                          SkFloatToScalar(stopX), SkFloatToScalar(stopY),
 396                          *paint);
 397     }
 398
 399     static void drawRect__RectFPaint(JNIEnv* env, jobject, SkCanvas* canvas,
 400                                      jobject rect, SkPaint* paint) {
 401         SkRect rect_;
 402         GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
 403         canvas->drawRect(rect_, *paint);
 404     }
 405
 406     static void drawRect__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas,
 407                                     jfloat left, jfloat top, jfloat right,
 408                                     jfloat bottom, SkPaint* paint) {
 409         SkScalar left_ = SkFloatToScalar(left);
 410         SkScalar top_ = SkFloatToScalar(top);
 411         SkScalar right_ = SkFloatToScalar(right);
 412         SkScalar bottom_ = SkFloatToScalar(bottom);
 413         canvas->drawRectCoords(left_, top_, right_, bottom_, *paint);
 414     }
 415
 416     static void drawOval(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval,
 417                          SkPaint* paint) {
 418         SkRect oval;
 419         GraphicsJNI::jrectf_to_rect(env, joval, &oval);
 420         canvas->drawOval(oval, *paint);
 421     }
 422
 423     static void drawCircle(JNIEnv* env, jobject, SkCanvas* canvas, jfloat cx,
 424                            jfloat cy, jfloat radius, SkPaint* paint) {
 425         canvas->drawCircle(SkFloatToScalar(cx), SkFloatToScalar(cy),
 426                            SkFloatToScalar(radius), *paint);
 427     }
 428
 429     static void drawArc(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval,
 430                         jfloat startAngle, jfloat sweepAngle,
 431                         jboolean useCenter, SkPaint* paint) {
 432         SkRect oval;
 433         GraphicsJNI::jrectf_to_rect(env, joval, &oval);
 434         canvas->drawArc(oval, SkFloatToScalar(startAngle),
 435                         SkFloatToScalar(sweepAngle), useCenter, *paint);
 436     }
 437
 438     static void drawRoundRect(JNIEnv* env, jobject, SkCanvas* canvas,
 439                               jobject jrect, jfloat rx, jfloat ry,
 440                               SkPaint* paint) {
 441         SkRect rect;
 442         GraphicsJNI::jrectf_to_rect(env, jrect, &rect);
 443         canvas->drawRoundRect(rect, SkFloatToScalar(rx), SkFloatToScalar(ry),
 444                               *paint);
 445     }
 446
 447     static void drawPath(JNIEnv* env, jobject, SkCanvas* canvas, SkPath* path,
 448                          SkPaint* paint) {
 449         canvas->drawPath(*path, *paint);
 450     }
 451
 452     static void drawPicture(JNIEnv* env, jobject, SkCanvas* canvas,
 453                             SkPicture* picture) {
 454         SkASSERT(canvas);
 455         SkASSERT(picture);
 456
 457 #ifdef TIME_DRAW
 458         SkMSec now = get_thread_msec(); //SkTime::GetMSecs();
 459 #endif
 460         canvas->drawPicture(*picture);
 461 #ifdef TIME_DRAW
 462         LOGD("---- picture playback %d ms\n", get_thread_msec() - now);
 463 #endif
 464     }
 465
 466     static void drawBitmap__BitmapFFPaint(JNIEnv* env, jobject jcanvas,
 467                                           SkCanvas* canvas, SkBitmap* bitmap,
 468                                           jfloat left, jfloat top,
 469                                           SkPaint* paint, jint canvasDensity,
 470                                           jint screenDensity, jint bitmapDensity) {
 471         SkScalar left_ = SkFloatToScalar(left);
 472         SkScalar top_ = SkFloatToScalar(top);
 473
 474         if (canvasDensity == bitmapDensity || canvasDensity == 0
 475                 || bitmapDensity == 0) {
 476             if (screenDensity != 0 && screenDensity != bitmapDensity) {
 477                 SkPaint filteredPaint;
 478                 if (paint) {
 479                     filteredPaint = *paint;
 480                 }
 481                 filteredPaint.setFilterBitmap(true);
 482                 canvas->drawBitmap(*bitmap, left_, top_, &filteredPaint);
 483             } else {
 484                 canvas->drawBitmap(*bitmap, left_, top_, paint);
 485             }
 486         } else {
 487             canvas->save();
 488             SkScalar scale = SkFloatToScalar(canvasDensity / (float)bitmapDensity);
 489             canvas->translate(left_, top_);
 490             canvas->scale(scale, scale);
 491
 492             SkPaint filteredPaint;
 493             if (paint) {
 494                 filteredPaint = *paint;
 495             }
 496             filteredPaint.setFilterBitmap(true);
 497
 498             canvas->drawBitmap(*bitmap, 0, 0, &filteredPaint);
 499
 500             canvas->restore();
 501         }
 502     }
 503
 504     static void doDrawBitmap(JNIEnv* env, SkCanvas* canvas, SkBitmap* bitmap,
 505                         jobject srcIRect, const SkRect& dst, SkPaint* paint,
 506                         jint screenDensity, jint bitmapDensity) {
 507         SkIRect    src, *srcPtr = NULL;
 508
 509         if (NULL != srcIRect) {
 510             GraphicsJNI::jrect_to_irect(env, srcIRect, &src);
 511             srcPtr = &src;
 512         }
 513
 514         if (screenDensity != 0 && screenDensity != bitmapDensity) {
 515             SkPaint filteredPaint;
 516             if (paint) {
 517                 filteredPaint = *paint;
 518             }
 519             filteredPaint.setFilterBitmap(true);
 520             canvas->drawBitmapRect(*bitmap, srcPtr, dst, &filteredPaint);
 521         } else {
 522             canvas->drawBitmapRect(*bitmap, srcPtr, dst, paint);
 523         }
 524     }
 525
 526     static void drawBitmapRF(JNIEnv* env, jobject, SkCanvas* canvas,
 527                              SkBitmap* bitmap, jobject srcIRect,
 528                              jobject dstRectF, SkPaint* paint,
 529                              jint screenDensity, jint bitmapDensity) {
 530         SkRect      dst;
 531         GraphicsJNI::jrectf_to_rect(env, dstRectF, &dst);
 532         doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint,
 533                 screenDensity, bitmapDensity);
 534     }
 535
 536     static void drawBitmapRR(JNIEnv* env, jobject, SkCanvas* canvas,
 537                              SkBitmap* bitmap, jobject srcIRect,
 538                              jobject dstRect, SkPaint* paint,
 539                              jint screenDensity, jint bitmapDensity) {
 540         SkRect      dst;
 541         GraphicsJNI::jrect_to_rect(env, dstRect, &dst);
 542         doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint,
 543                 screenDensity, bitmapDensity);
 544     }
 545
 546     static void drawBitmapArray(JNIEnv* env, jobject, SkCanvas* canvas,
 547                                 jintArray jcolors, int offset, int stride,
 548                                 jfloat x, jfloat y, int width, int height,
 549                                 jboolean hasAlpha, SkPaint* paint)
 550     {
 551         SkBitmap    bitmap;
 552
 553         bitmap.setConfig(hasAlpha ? SkBitmap::kARGB_8888_Config :
 554                          SkBitmap::kRGB_565_Config, width, height);
 555         if (!bitmap.allocPixels()) {
 556             return;
 557         }
 558
 559         if (!GraphicsJNI::SetPixels(env, jcolors, offset, stride,
 560                                     0, 0, width, height, bitmap)) {
 561             return;
 562         }
 563
 564         canvas->drawBitmap(bitmap, SkFloatToScalar(x), SkFloatToScalar(y),
 565                            paint);
 566     }
 567
 568     static void drawBitmapMatrix(JNIEnv* env, jobject, SkCanvas* canvas,
 569                                  const SkBitmap* bitmap, const SkMatrix* matrix,
 570                                  const SkPaint* paint) {
 571         canvas->drawBitmapMatrix(*bitmap, *matrix, paint);
 572     }
 573
 574     static void drawBitmapMesh(JNIEnv* env, jobject, SkCanvas* canvas,
 575                           const SkBitmap* bitmap, int meshWidth, int meshHeight,
 576                           jfloatArray jverts, int vertIndex, jintArray jcolors,
 577                           int colorIndex, const SkPaint* paint) {
 578
 579         const int ptCount = (meshWidth + 1) * (meshHeight + 1);
 580         const int indexCount = meshWidth * meshHeight * 6;
 581
 582         AutoJavaFloatArray  vertA(env, jverts, vertIndex + (ptCount << 1));
 583         AutoJavaIntArray    colorA(env, jcolors, colorIndex + ptCount);
 584
 585         /*  Our temp storage holds 2 or 3 arrays.
 586             texture points [ptCount * sizeof(SkPoint)]
 587             optionally vertex points [ptCount * sizeof(SkPoint)] if we need a
 588                 copy to convert from float to fixed
 589             indices [ptCount * sizeof(uint16_t)]
 590         */
 591         ssize_t storageSize = ptCount * sizeof(SkPoint); // texs[]
 592 #ifdef SK_SCALAR_IS_FIXED
 593         storageSize += ptCount * sizeof(SkPoint);  // storage for verts
 594 #endif
 595         storageSize += indexCount * sizeof(uint16_t);  // indices[]
 596
 597         SkAutoMalloc storage(storageSize);
 598         SkPoint* texs = (SkPoint*)storage.get();
 599         SkPoint* verts;
 600         uint16_t* indices;
 601 #ifdef SK_SCALAR_IS_FLOAT
 602         verts = (SkPoint*)(vertA.ptr() + vertIndex);
 603         indices = (uint16_t*)(texs + ptCount);
 604 #else
 605         verts = texs + ptCount;
 606         indices = (uint16_t*)(verts + ptCount);
 607         // convert floats to fixed
 608         {
 609             const float* src = vertA.ptr() + vertIndex;
 610             for (int i = 0; i < ptCount; i++) {
 611                 verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1]));
 612                 src += 2;
 613             }
 614         }
 615 #endif
 616
 617         // cons up texture coordinates and indices
 618         {
 619             const SkScalar w = SkIntToScalar(bitmap->width());
 620             const SkScalar h = SkIntToScalar(bitmap->height());
 621             const SkScalar dx = w / meshWidth;
 622             const SkScalar dy = h / meshHeight;
 623
 624             SkPoint* texsPtr = texs;
 625             SkScalar y = 0;
 626             for (int i = 0; i <= meshHeight; i++) {
 627                 if (i == meshHeight) {
 628                     y = h;  // to ensure numerically we hit h exactly
 629                 }
 630                 SkScalar x = 0;
 631                 for (int j = 0; j < meshWidth; j++) {
 632                     texsPtr->set(x, y);
 633                     texsPtr += 1;
 634                     x += dx;
 635                 }
 636                 texsPtr->set(w, y);
 637                 texsPtr += 1;
 638                 y += dy;
 639             }
 640             SkASSERT(texsPtr - texs == ptCount);
 641         }
 642
 643         // cons up indices
 644         {
 645             uint16_t* indexPtr = indices;
 646             int index = 0;
 647             for (int i = 0; i < meshHeight; i++) {
 648                 for (int j = 0; j < meshWidth; j++) {
 649                     // lower-left triangle
 650                     *indexPtr++ = index;
 651                     *indexPtr++ = index + meshWidth + 1;
 652                     *indexPtr++ = index + meshWidth + 2;
 653                     // upper-right triangle
 654                     *indexPtr++ = index;
 655                     *indexPtr++ = index + meshWidth + 2;
 656                     *indexPtr++ = index + 1;
 657                     // bump to the next cell
 658                     index += 1;
 659                 }
 660                 // bump to the next row
 661                 index += 1;
 662             }
 663             SkASSERT(indexPtr - indices == indexCount);
 664             SkASSERT((char*)indexPtr - (char*)storage.get() == storageSize);
 665         }
 666
 667         // double-check that we have legal indices
 668 #ifdef SK_DEBUG
 669         {
 670             for (int i = 0; i < indexCount; i++) {
 671                 SkASSERT((unsigned)indices[i] < (unsigned)ptCount);
 672             }
 673         }
 674 #endif
 675
 676         // cons-up a shader for the bitmap
 677         SkPaint tmpPaint;
 678         if (paint) {
 679             tmpPaint = *paint;
 680         }
 681         SkShader* shader = SkShader::CreateBitmapShader(*bitmap,
 682                         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
 683         tmpPaint.setShader(shader)->safeUnref();
 684
 685         canvas->drawVertices(SkCanvas::kTriangles_VertexMode, ptCount, verts,
 686                              texs, (const SkColor*)colorA.ptr(), NULL, indices,
 687                              indexCount, tmpPaint);
 688     }
 689
 690     static void drawVertices(JNIEnv* env, jobject, SkCanvas* canvas,
 691                              SkCanvas::VertexMode mode, int vertexCount,
 692                              jfloatArray jverts, int vertIndex,
 693                              jfloatArray jtexs, int texIndex,
 694                              jintArray jcolors, int colorIndex,
 695                              jshortArray jindices, int indexIndex,
 696                              int indexCount, const SkPaint* paint) {
 697
 698         AutoJavaFloatArray  vertA(env, jverts, vertIndex + vertexCount);
 699         AutoJavaFloatArray  texA(env, jtexs, texIndex + vertexCount);
 700         AutoJavaIntArray    colorA(env, jcolors, colorIndex + vertexCount);
 701         AutoJavaShortArray  indexA(env, jindices, indexIndex + indexCount);
 702
 703         const int ptCount = vertexCount >> 1;
 704
 705         SkPoint* verts;
 706         SkPoint* texs = NULL;
 707 #ifdef SK_SCALAR_IS_FLOAT
 708         verts = (SkPoint*)(vertA.ptr() + vertIndex);
 709         if (jtexs != NULL) {
 710             texs = (SkPoint*)(texA.ptr() + texIndex);
 711         }
 712 #else
 713         int count = ptCount;    // for verts
 714         if (jtexs != NULL) {
 715             count += ptCount;   // += for texs
 716         }
 717         SkAutoMalloc storage(count * sizeof(SkPoint));
 718         verts = (SkPoint*)storage.get();
 719         const float* src = vertA.ptr() + vertIndex;
 720         for (int i = 0; i < ptCount; i++) {
 721             verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1]));
 722             src += 2;
 723         }
 724         if (jtexs != NULL) {
 725             texs = verts + ptCount;
 726             src = texA.ptr() + texIndex;
 727             for (int i = 0; i < ptCount; i++) {
 728                 texs[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1]));
 729                 src += 2;
 730             }
 731         }
 732 #endif
 733
 734         const SkColor* colors = NULL;
 735         const uint16_t* indices = NULL;
 736         if (jcolors != NULL) {
 737             colors = (const SkColor*)(colorA.ptr() + colorIndex);
 738         }
 739         if (jindices != NULL) {
 740             indices = (const uint16_t*)(indexA.ptr() + indexIndex);
 741         }
 742
 743         canvas->drawVertices(mode, ptCount, verts, texs, colors, NULL,
 744                              indices, indexCount, *paint);
 745     }
 746
 747     static void drawText___CIIFFPaint(JNIEnv* env, jobject, SkCanvas* canvas,
 748                                       jcharArray text, int index, int count,
 749                                       jfloat x, jfloat y, SkPaint* paint) {
 750         jchar* textArray = env->GetCharArrayElements(text, NULL);
 751         jsize textCount = env->GetArrayLength(text);
 752         SkScalar x_ = SkFloatToScalar(x);
 753         SkScalar y_ = SkFloatToScalar(y);
 754         canvas->drawText(textArray + index, count << 1, x_, y_, *paint);
 755         env->ReleaseCharArrayElements(text, textArray, 0);
 756     }
 757
 758     static void drawText__StringIIFFPaint(JNIEnv* env, jobject,
 759                             SkCanvas* canvas, jstring text, int start, int end,
 760                                           jfloat x, jfloat y, SkPaint* paint) {
 761         const void* text_ = env->GetStringChars(text, NULL);
 762         SkScalar x_ = SkFloatToScalar(x);
 763         SkScalar y_ = SkFloatToScalar(y);
 764         canvas->drawText((const uint16_t*)text_ + start, (end - start) << 1,
 765                          x_, y_, *paint);
 766         env->ReleaseStringChars(text, (const jchar*) text_);
 767     }
 768
 769     static void drawString(JNIEnv* env, jobject canvas, jstring text,
 770                            jfloat x, jfloat y, jobject paint) {
 771         NPE_CHECK_RETURN_VOID(env, canvas);
 772         NPE_CHECK_RETURN_VOID(env, paint);
 773         NPE_CHECK_RETURN_VOID(env, text);
 774         size_t count = env->GetStringLength(text);
 775         if (0 == count) {
 776             return;
 777         }
 778         const jchar* text_ = env->GetStringChars(text, NULL);
 779         SkCanvas* c = GraphicsJNI::getNativeCanvas(env, canvas);
 780         c->drawText(text_, count << 1, SkFloatToScalar(x), SkFloatToScalar(y),
 781                     *GraphicsJNI::getNativePaint(env, paint));
 782         env->ReleaseStringChars(text, text_);
 783     }
 784
 785     static void drawPosText___CII_FPaint(JNIEnv* env, jobject, SkCanvas* canvas,
 786                                          jcharArray text, int index, int count,
 787                                          jfloatArray pos, SkPaint* paint) {
 788         jchar* textArray = text ? env->GetCharArrayElements(text, NULL) : NULL;
 789         jsize textCount = text ? env->GetArrayLength(text) : NULL;
 790         float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL;
 791         int posCount = pos ? env->GetArrayLength(pos) >> 1: 0;
 792         SkPoint* posPtr = posCount > 0 ? new SkPoint[posCount] : NULL;
 793         int indx;
 794         for (indx = 0; indx < posCount; indx++) {
 795             posPtr[indx].fX = SkFloatToScalar(posArray[indx << 1]);
 796             posPtr[indx].fY = SkFloatToScalar(posArray[(indx << 1) + 1]);
 797         }
 798         canvas->drawPosText(textArray + index, count << 1, posPtr, *paint);
 799         if (text) {
 800             env->ReleaseCharArrayElements(text, textArray, 0);
 801         }
 802         if (pos) {
 803             env->ReleaseFloatArrayElements(pos, posArray, 0);
 804         }
 805         delete[] posPtr;
 806     }
 807
 808     static void drawPosText__String_FPaint(JNIEnv* env, jobject,
 809                                            SkCanvas* canvas, jstring text,
 810                                            jfloatArray pos, SkPaint* paint) {
 811         const void* text_ = text ? env->GetStringChars(text, NULL) : NULL;
 812         int byteLength = text ? env->GetStringLength(text) : 0;
 813         float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL;
 814         int posCount = pos ? env->GetArrayLength(pos) >> 1: 0;
 815         SkPoint* posPtr = posCount > 0 ? new SkPoint[posCount] : NULL;
 816
 817         for (int indx = 0; indx < posCount; indx++) {
 818             posPtr[indx].fX = SkFloatToScalar(posArray[indx << 1]);
 819             posPtr[indx].fY = SkFloatToScalar(posArray[(indx << 1) + 1]);
 820         }
 821         canvas->drawPosText(text_, byteLength << 1, posPtr, *paint);
 822         if (text) {
 823             env->ReleaseStringChars(text, (const jchar*) text_);
 824         }
 825         if (pos) {
 826             env->ReleaseFloatArrayElements(pos, posArray, 0);
 827         }
 828         delete[] posPtr;
 829     }
 830
 831     static void drawTextOnPath___CIIPathFFPaint(JNIEnv* env, jobject,
 832                         SkCanvas* canvas, jcharArray text, int index, int count,
 833                 SkPath* path, jfloat hOffset, jfloat vOffset, SkPaint* paint) {
 834
 835         jchar* textArray = env->GetCharArrayElements(text, NULL);
 836         canvas->drawTextOnPathHV(textArray + index, count << 1, *path,
 837                     SkFloatToScalar(hOffset), SkFloatToScalar(vOffset), *paint);
 838         env->ReleaseCharArrayElements(text, textArray, 0);
 839     }
 840
 841     static void drawTextOnPath__StringPathFFPaint(JNIEnv* env, jobject,
 842                             SkCanvas* canvas, jstring text, SkPath* path,
 843                             jfloat hOffset, jfloat vOffset, SkPaint* paint) {
 844         const jchar* text_ = env->GetStringChars(text, NULL);
 845         int byteLength = env->GetStringLength(text) << 1;
 846         canvas->drawTextOnPathHV(text_, byteLength, *path,
 847                     SkFloatToScalar(hOffset), SkFloatToScalar(vOffset), *paint);
 848         env->ReleaseStringChars(text, text_);
 849     }
 850
 851     static bool getClipBounds(JNIEnv* env, jobject, SkCanvas* canvas,
 852                               jobject bounds) {
 853         SkRect   r;
 854         SkIRect ir;
 855         bool     result = canvas->getClipBounds(&r, SkCanvas::kBW_EdgeType);
 856
 857         r.round(&ir);
 858         (void)GraphicsJNI::irect_to_jrect(ir, env, bounds);
 859         return result;
 860     }
 861
 862     static void getCTM(JNIEnv* env, jobject, SkCanvas* canvas,
 863                        SkMatrix* matrix) {
 864         *matrix = canvas->getTotalMatrix();
 865     }
 866 };
 867
 868 static JNINativeMethod gCanvasMethods[] = {
 869     {"finalizer", "(I)V", (void*) SkCanvasGlue::finalizer},
 870     {"initRaster","(I)I", (void*) SkCanvasGlue::initRaster},
 871     {"initGL","()I", (void*) SkCanvasGlue::initGL},
 872     {"isOpaque","()Z", (void*) SkCanvasGlue::isOpaque},
 873     {"getWidth","()I", (void*) SkCanvasGlue::getWidth},
 874     {"getHeight","()I", (void*) SkCanvasGlue::getHeight},
 875     {"native_setBitmap","(II)V", (void*) SkCanvasGlue::setBitmap},
 876     {"nativeSetViewport", "(III)V", (void*) SkCanvasGlue::setViewport},
 877     {"save","()I", (void*) SkCanvasGlue::saveAll},
 878     {"save","(I)I", (void*) SkCanvasGlue::save},
 879     {"native_saveLayer","(ILandroid/graphics/RectF;II)I",
 880         (void*) SkCanvasGlue::saveLayer},
 881     {"native_saveLayer","(IFFFFII)I", (void*) SkCanvasGlue::saveLayer4F},
 882     {"native_saveLayerAlpha","(ILandroid/graphics/RectF;II)I",
 883         (void*) SkCanvasGlue::saveLayerAlpha},
 884     {"native_saveLayerAlpha","(IFFFFII)I",
 885         (void*) SkCanvasGlue::saveLayerAlpha4F},
 886     {"restore","()V", (void*) SkCanvasGlue::restore},
 887     {"getSaveCount","()I", (void*) SkCanvasGlue::getSaveCount},
 888     {"restoreToCount","(I)V", (void*) SkCanvasGlue::restoreToCount},
 889     {"translate","(FF)V", (void*) SkCanvasGlue::translate},
 890     {"scale","(FF)V", (void*) SkCanvasGlue::scale__FF},
 891     {"rotate","(F)V", (void*) SkCanvasGlue::rotate__F},
 892     {"skew","(FF)V", (void*) SkCanvasGlue::skew__FF},
 893     {"native_concat","(II)V", (void*) SkCanvasGlue::concat},
 894     {"native_setMatrix","(II)V", (void*) SkCanvasGlue::setMatrix},
 895     {"clipRect","(FFFF)Z", (void*) SkCanvasGlue::clipRect_FFFF},
 896     {"clipRect","(IIII)Z", (void*) SkCanvasGlue::clipRect_IIII},
 897     {"clipRect","(Landroid/graphics/RectF;)Z",
 898         (void*) SkCanvasGlue::clipRect_RectF},
 899     {"clipRect","(Landroid/graphics/Rect;)Z",
 900         (void*) SkCanvasGlue::clipRect_Rect},
 901     {"native_clipRect","(IFFFFI)Z", (void*) SkCanvasGlue::clipRect},
 902     {"native_clipPath","(III)Z", (void*) SkCanvasGlue::clipPath},
 903     {"native_clipRegion","(III)Z", (void*) SkCanvasGlue::clipRegion},
 904     {"nativeSetDrawFilter", "(II)V", (void*) SkCanvasGlue::setDrawFilter},
 905     {"native_getClipBounds","(ILandroid/graphics/Rect;)Z",
 906         (void*) SkCanvasGlue::getClipBounds},
 907     {"native_getCTM", "(II)V", (void*)SkCanvasGlue::getCTM},
 908     {"native_quickReject","(ILandroid/graphics/RectF;I)Z",
 909         (void*) SkCanvasGlue::quickReject__RectFI},
 910     {"native_quickReject","(III)Z", (void*) SkCanvasGlue::quickReject__PathI},
 911     {"native_quickReject","(IFFFFI)Z", (void*)SkCanvasGlue::quickReject__FFFFI},
 912     {"native_drawRGB","(IIII)V", (void*) SkCanvasGlue::drawRGB},
 913     {"native_drawARGB","(IIIII)V", (void*) SkCanvasGlue::drawARGB},
 914     {"native_drawColor","(II)V", (void*) SkCanvasGlue::drawColor__I},
 915     {"native_drawColor","(III)V", (void*) SkCanvasGlue::drawColor__II},
 916     {"native_drawPaint","(II)V", (void*) SkCanvasGlue::drawPaint},
 917     {"drawPoint", "(FFLandroid/graphics/Paint;)V",
 918     (void*) SkCanvasGlue::drawPoint},
 919     {"drawPoints", "([FIILandroid/graphics/Paint;)V",
 920         (void*) SkCanvasGlue::drawPoints},
 921     {"drawLines", "([FIILandroid/graphics/Paint;)V",
 922         (void*) SkCanvasGlue::drawLines},
 923     {"native_drawLine","(IFFFFI)V", (void*) SkCanvasGlue::drawLine__FFFFPaint},
 924     {"native_drawRect","(ILandroid/graphics/RectF;I)V",
 925         (void*) SkCanvasGlue::drawRect__RectFPaint},
 926     {"native_drawRect","(IFFFFI)V", (void*) SkCanvasGlue::drawRect__FFFFPaint},
 927     {"native_drawOval","(ILandroid/graphics/RectF;I)V",
 928         (void*) SkCanvasGlue::drawOval},
 929     {"native_drawCircle","(IFFFI)V", (void*) SkCanvasGlue::drawCircle},
 930     {"native_drawArc","(ILandroid/graphics/RectF;FFZI)V",
 931         (void*) SkCanvasGlue::drawArc},
 932     {"native_drawRoundRect","(ILandroid/graphics/RectF;FFI)V",
 933         (void*) SkCanvasGlue::drawRoundRect},
 934     {"native_drawPath","(III)V", (void*) SkCanvasGlue::drawPath},
 935     {"native_drawBitmap","(IIFFIIII)V",
 936         (void*) SkCanvasGlue::drawBitmap__BitmapFFPaint},
 937     {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/RectF;III)V",
 938         (void*) SkCanvasGlue::drawBitmapRF},
 939     {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/Rect;III)V",
 940         (void*) SkCanvasGlue::drawBitmapRR},
 941     {"native_drawBitmap", "(I[IIIFFIIZI)V",
 942     (void*)SkCanvasGlue::drawBitmapArray},
 943
 944     {"nativeDrawBitmapMatrix", "(IIII)V",
 945         (void*)SkCanvasGlue::drawBitmapMatrix},
 946     {"nativeDrawBitmapMesh", "(IIII[FI[III)V",
 947         (void*)SkCanvasGlue::drawBitmapMesh},
 948     {"nativeDrawVertices", "(III[FI[FI[II[SIII)V",
 949         (void*)SkCanvasGlue::drawVertices},
 950     {"native_drawText","(I[CIIFFI)V",
 951         (void*) SkCanvasGlue::drawText___CIIFFPaint},
 952     {"native_drawText","(ILjava/lang/String;IIFFI)V",
 953         (void*) SkCanvasGlue::drawText__StringIIFFPaint},
 954     {"drawText","(Ljava/lang/String;FFLandroid/graphics/Paint;)V",
 955         (void*) SkCanvasGlue::drawString},
 956     {"native_drawPosText","(I[CII[FI)V",
 957         (void*) SkCanvasGlue::drawPosText___CII_FPaint},
 958     {"native_drawPosText","(ILjava/lang/String;[FI)V",
 959         (void*) SkCanvasGlue::drawPosText__String_FPaint},
 960     {"native_drawTextOnPath","(I[CIIIFFI)V",
 961         (void*) SkCanvasGlue::drawTextOnPath___CIIPathFFPaint},
 962     {"native_drawTextOnPath","(ILjava/lang/String;IFFI)V",
 963         (void*) SkCanvasGlue::drawTextOnPath__StringPathFFPaint},
 964     {"native_drawPicture", "(II)V", (void*) SkCanvasGlue::drawPicture},
 965
 966     {"freeCaches", "()V", (void*) SkCanvasGlue::freeCaches}
 967 };
 968
 969 ///////////////////////////////////////////////////////////////////////////////
 970
 971 static void BoundaryPatch_computeCubic(JNIEnv* env, jobject, jfloatArray jpts,
 972                                    int texW, int texH, int rows, int cols,
 973                                    jfloatArray jverts, jshortArray jidx) {
 974     AutoJavaFloatArray ptsArray(env, jpts, 24, kRO_JNIAccess);
 975
 976     int vertCount = rows * cols;
 977     AutoJavaFloatArray vertsArray(env, jverts, vertCount * 4, kRW_JNIAccess);
 978     SkPoint* verts = (SkPoint*)vertsArray.ptr();
 979     SkPoint* texs = verts + vertCount;
 980
 981     int idxCount = (rows - 1) * (cols - 1) * 6;
 982     AutoJavaShortArray idxArray(env, jidx, idxCount, kRW_JNIAccess);
 983     uint16_t* idx = (uint16_t*)idxArray.ptr();  // cast from int16_t*
 984
 985     SkCubicBoundary cubic;
 986     memcpy(cubic.fPts, ptsArray.ptr(), 12 * sizeof(SkPoint));
 987
 988     SkBoundaryPatch patch;
 989     patch.setBoundary(&cubic);
 990     // generate our verts
 991     patch.evalPatch(verts, rows, cols);
 992
 993     SkMeshIndices mesh;
 994     // generate our texs and idx
 995     mesh.init(texs, idx, texW, texH, rows, cols);
 996 }
 997
 998 static JNINativeMethod gBoundaryPatchMethods[] = {
 999     {"nativeComputeCubicPatch", "([FIIII[F[S)V",
1000     (void*)BoundaryPatch_computeCubic },
1001 };
1002
1003 ///////////////////////////////////////////////////////////////////////////////
1004
1005 #include <android_runtime/AndroidRuntime.h>
1006
1007 #define REG(env, name, array) \
1008     result = android::AndroidRuntime::registerNativeMethods(env, name, array, \
1009                                                     SK_ARRAY_COUNT(array));  \
1010     if (result < 0) return result
1011
1012 int register_android_graphics_Canvas(JNIEnv* env) {
1013     int result;
1014
1015     REG(env, "android/graphics/Canvas", gCanvasMethods);
1016     REG(env, "android/graphics/utils/BoundaryPatch", gBoundaryPatchMethods);
1017
1018     return result;
1019 }
1020
1021 }