1 /*
   2  * Copyright (c) 2007, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #include "jni.h"
  27 #include "jni_util.h"
  28 #include "jlong.h"
  29 #include "sunfontids.h"
  30 #include "sun_font_FreetypeFontScaler.h"
  31 
  32 #include <stdlib.h>
  33 #if !defined(_WIN32) && !defined(__APPLE_)
  34 #include <dlfcn.h>
  35 #endif
  36 #include <math.h>
  37 #include "ft2build.h"
  38 #include FT_FREETYPE_H
  39 #include FT_GLYPH_H
  40 #include FT_BBOX_H
  41 #include FT_SIZES_H
  42 #include FT_OUTLINE_H
  43 #include FT_SYNTHESIS_H
  44 #include FT_LCD_FILTER_H
  45 #include FT_MODULE_H
  46 
  47 #include "fontscaler.h"
  48 
  49 #define  ftFixed1  (FT_Fixed) (1 << 16)
  50 #define  FloatToFTFixed(f) (FT_Fixed)((f) * (float)(ftFixed1))
  51 #define  FTFixedToFloat(x) ((x) / (float)(ftFixed1))
  52 #define  FT26Dot6ToFloat(x)  ((x) / ((float) (1<<6)))
  53 #define  FT26Dot6ToInt(x) (((int)(x)) >> 6)
  54 
  55 typedef struct {
  56     /* Important note:
  57          JNI forbids sharing same env between different threads.
  58          We are safe, because pointer is overwritten every time we get into
  59          JNI call (see setupFTContext).
  60 
  61          Pointer is used by font data reading callbacks
  62          such as ReadTTFontFileFunc.
  63 
  64          NB: We may consider switching to JNI_GetEnv. */
  65     JNIEnv* env;
  66     FT_Library library;
  67     FT_Face face;
  68     FT_Stream faceStream;
  69     jobject font2D;
  70     jobject directBuffer;
  71 
  72     unsigned char* fontData;
  73     unsigned fontDataOffset;
  74     unsigned fontDataLength;
  75     unsigned fileSize;
  76 } FTScalerInfo;
  77 
  78 typedef struct FTScalerContext {
  79     FT_Matrix  transform;     /* glyph transform, including device transform */
  80     jboolean   useSbits;      /* sbit usage enabled? */
  81     jint       aaType;        /* antialiasing mode (off/on/grey/lcd) */
  82     jint       fmType;        /* fractional metrics - on/off */
  83     jboolean   doBold;        /* perform algorithmic bolding? */
  84     jboolean   doItalize;     /* perform algorithmic italicizing? */
  85     int        renderFlags;   /* configuration specific to particular engine */
  86     int        pathType;
  87     int        ptsz;          /* size in points */
  88 } FTScalerContext;
  89 
  90 #ifdef DEBUG
  91 /* These are referenced in the freetype sources if DEBUG macro is defined.
  92    To simplify work with debuging version of freetype we define
  93    them here. */
  94 int z_verbose;
  95 void z_error(char *s) {}
  96 #endif
  97 
  98 /**************** Error handling utilities *****************/
  99 
 100 static jmethodID invalidateScalerMID;
 101 
 102 JNIEXPORT void JNICALL
 103 Java_sun_font_FreetypeFontScaler_initIDs(
 104         JNIEnv *env, jobject scaler, jclass FFSClass) {
 105     invalidateScalerMID =
 106         (*env)->GetMethodID(env, FFSClass, "invalidateScaler", "()V");
 107 }
 108 
 109 static void freeNativeResources(JNIEnv *env, FTScalerInfo* scalerInfo) {
 110 
 111     if (scalerInfo == NULL)
 112         return;
 113 
 114     // FT_Done_Face always closes the stream, but only frees the memory
 115     // of the data structure if it was internally allocated by FT.
 116     // We hold on to a pointer to the stream structure if we provide it
 117     // ourselves, so that we can free it here.
 118     FT_Done_Face(scalerInfo->face);
 119     FT_Done_FreeType(scalerInfo->library);
 120 
 121     if (scalerInfo->directBuffer != NULL) {
 122         (*env)->DeleteGlobalRef(env, scalerInfo->directBuffer);
 123     }
 124 
 125     if (scalerInfo->fontData != NULL) {
 126         free(scalerInfo->fontData);
 127     }
 128 
 129     if (scalerInfo->faceStream != NULL) {
 130         free(scalerInfo->faceStream);
 131     }
 132     free(scalerInfo);
 133 }
 134 
 135 /* invalidates state of java scaler object */
 136 static void invalidateJavaScaler(JNIEnv *env,
 137                                  jobject scaler,
 138                                  FTScalerInfo* scalerInfo) {
 139     freeNativeResources(env, scalerInfo);
 140     (*env)->CallVoidMethod(env, scaler, invalidateScalerMID);
 141 }
 142 
 143 /******************* I/O handlers ***************************/
 144 
 145 #define FILEDATACACHESIZE 1024
 146 
 147 static unsigned long ReadTTFontFileFunc(FT_Stream stream,
 148                                         unsigned long offset,
 149                                         unsigned char* destBuffer,
 150                                         unsigned long numBytes)
 151 {
 152     FTScalerInfo *scalerInfo = (FTScalerInfo *) stream->pathname.pointer;
 153     JNIEnv* env = scalerInfo->env;
 154     jobject bBuffer;
 155     int bread = 0;
 156 
 157     if (numBytes == 0) return 0;
 158 
 159     /* Large reads will bypass the cache and data copying */
 160     if (numBytes > FILEDATACACHESIZE) {
 161         bBuffer = (*env)->NewDirectByteBuffer(env, destBuffer, numBytes);
 162         if (bBuffer != NULL) {
 163             bread = (*env)->CallIntMethod(env,
 164                                           scalerInfo->font2D,
 165                                           sunFontIDs.ttReadBlockMID,
 166                                           bBuffer, offset, numBytes);
 167             return bread;
 168         } else {
 169             /* We probably hit bug 4845371. For reasons that
 170              * are currently unclear, the call stacks after the initial
 171              * createScaler call that read large amounts of data seem to
 172              * be OK and can create the byte buffer above, but this code
 173              * is here just in case.
 174              * 4845371 is fixed now so I don't expect this code path to
 175              * ever get called but its harmless to leave it here on the
 176              * small chance its needed.
 177              */
 178             jbyteArray byteArray = (jbyteArray)
 179             (*env)->CallObjectMethod(env, scalerInfo->font2D,
 180                                      sunFontIDs.ttReadBytesMID,
 181                                      offset, numBytes);
 182             (*env)->GetByteArrayRegion(env, byteArray,
 183                                        0, numBytes, (jbyte*)destBuffer);
 184             return numBytes;
 185         }
 186     } /* Do we have a cache hit? */
 187       else if (scalerInfo->fontDataOffset <= offset &&
 188         scalerInfo->fontDataOffset + scalerInfo->fontDataLength >=
 189                                                          offset + numBytes)
 190     {
 191         unsigned cacheOffset = offset - scalerInfo->fontDataOffset;
 192 
 193         memcpy(destBuffer, scalerInfo->fontData+(size_t)cacheOffset, numBytes);
 194         return numBytes;
 195     } else {
 196         /* Must fill the cache */
 197         scalerInfo->fontDataOffset = offset;
 198         scalerInfo->fontDataLength =
 199                  (offset + FILEDATACACHESIZE > scalerInfo->fileSize) ?
 200                  scalerInfo->fileSize - offset : FILEDATACACHESIZE;
 201         bBuffer = scalerInfo->directBuffer;
 202         bread = (*env)->CallIntMethod(env, scalerInfo->font2D,
 203                                       sunFontIDs.ttReadBlockMID,
 204                                       bBuffer, offset,
 205                                       scalerInfo->fontDataLength);
 206         memcpy(destBuffer, scalerInfo->fontData, numBytes);
 207         return numBytes;
 208     }
 209 }
 210 
 211 typedef FT_Error (*FT_Prop_Set_Func)(FT_Library library,
 212                                      const FT_String*  module_name,
 213                                      const FT_String*  property_name,
 214                                      const void*       value );
 215 
 216 /**
 217  * Prefer the older v35 freetype byte code interpreter.
 218  */
 219 static void setInterpreterVersion(FT_Library library) {
 220 
 221     char* props = getenv("FREETYPE_PROPERTIES");
 222     int version = 35;
 223     const char* module = "truetype";
 224     const char* property = "interpreter-version";
 225 
 226     /* If some one is setting this, don't override it */
 227     if (props != NULL && strstr(property, props)) {
 228         return;
 229     }
 230     /*
 231      * FT_Property_Set was introduced in 2.4.11.
 232      * Some older supported Linux OSes may not include it so look
 233      * this up dynamically.
 234      * And if its not available it doesn't matter, since the reason
 235      * we need it dates from 2.7.
 236      * On Windows & Mac the library is always bundled so it is safe
 237      * to use directly in those cases.
 238      */
 239 #if defined(_WIN32) || defined(__APPLE__)
 240     FT_Property_Set(library, module, property, (void*)(&version));
 241 #else
 242     void *lib = dlopen("libfreetype.so", RTLD_LOCAL|RTLD_LAZY);
 243     if (lib == NULL) {
 244         lib = dlopen("libfreetype.so.6", RTLD_LOCAL|RTLD_LAZY);
 245         if (lib == NULL) {
 246             return;
 247         }
 248     }
 249     FT_Prop_Set_Func func = (FT_Prop_Set_Func)dlsym(lib, "FT_Property_Set");
 250     if (func != NULL) {
 251         func(library, module, property, (void*)(&version));
 252     }
 253     dlclose(lib);
 254 #endif
 255 }
 256 
 257 /*
 258  * Class:     sun_font_FreetypeFontScaler
 259  * Method:    initNativeScaler
 260  * Signature: (Lsun/font/Font2D;IIZI)J
 261  */
 262 JNIEXPORT jlong JNICALL
 263 Java_sun_font_FreetypeFontScaler_initNativeScaler(
 264         JNIEnv *env, jobject scaler, jobject font2D, jint type,
 265         jint indexInCollection, jboolean supportsCJK, jint filesize) {
 266     FTScalerInfo* scalerInfo = NULL;
 267     FT_Open_Args ft_open_args;
 268     int error;
 269     jobject bBuffer;
 270     scalerInfo = (FTScalerInfo*) calloc(1, sizeof(FTScalerInfo));
 271 
 272     if (scalerInfo == NULL)
 273         return 0;
 274 
 275     scalerInfo->env = env;
 276     scalerInfo->font2D = font2D;
 277     scalerInfo->fontDataOffset = 0;
 278     scalerInfo->fontDataLength = 0;
 279     scalerInfo->fileSize = filesize;
 280 
 281     /*
 282        We can consider sharing freetype library between different
 283        scalers. However, Freetype docs suggest to use different libraries
 284        for different threads. Also, our architecture implies that single
 285        FontScaler object is shared for different sizes/transforms/styles
 286        of the same font.
 287 
 288        On other hand these methods can not be concurrently executed
 289        becaused they are "synchronized" in java.
 290     */
 291     error = FT_Init_FreeType(&scalerInfo->library);
 292     if (error) {
 293         free(scalerInfo);
 294         return 0;
 295     }
 296     setInterpreterVersion(scalerInfo->library);
 297 
 298 #define TYPE1_FROM_JAVA        2
 299 
 300     error = 1; /* triggers memory freeing unless we clear it */
 301     if (type == TYPE1_FROM_JAVA) { /* TYPE1 */
 302         scalerInfo->fontData = (unsigned char*) malloc(filesize);
 303         scalerInfo->directBuffer = NULL;
 304         scalerInfo->fontDataLength = filesize;
 305 
 306         if (scalerInfo->fontData != NULL) {
 307             bBuffer = (*env)->NewDirectByteBuffer(env,
 308                                               scalerInfo->fontData,
 309                                               scalerInfo->fontDataLength);
 310             if (bBuffer != NULL) {
 311                 (*env)->CallVoidMethod(env, font2D,
 312                                    sunFontIDs.readFileMID, bBuffer);
 313 
 314                 error = FT_New_Memory_Face(scalerInfo->library,
 315                                    scalerInfo->fontData,
 316                                    scalerInfo->fontDataLength,
 317                                    indexInCollection,
 318                                    &scalerInfo->face);
 319             }
 320         }
 321     } else { /* Truetype */
 322         scalerInfo->fontData = (unsigned char*) malloc(FILEDATACACHESIZE);
 323 
 324         if (scalerInfo->fontData != NULL) {
 325             FT_Stream ftstream = (FT_Stream) calloc(1, sizeof(FT_StreamRec));
 326             if (ftstream != NULL) {
 327                 scalerInfo->directBuffer = (*env)->NewDirectByteBuffer(env,
 328                                            scalerInfo->fontData,
 329                                            FILEDATACACHESIZE);
 330                 if (scalerInfo->directBuffer != NULL) {
 331                     scalerInfo->directBuffer = (*env)->NewGlobalRef(env,
 332                                                scalerInfo->directBuffer);
 333                     ftstream->base = NULL;
 334                     ftstream->size = filesize;
 335                     ftstream->pos = 0;
 336                     ftstream->read = (FT_Stream_IoFunc) ReadTTFontFileFunc;
 337                     ftstream->close = NULL;
 338                     ftstream->pathname.pointer = (void *) scalerInfo;
 339 
 340                     memset(&ft_open_args, 0, sizeof(FT_Open_Args));
 341                     ft_open_args.flags = FT_OPEN_STREAM;
 342                     ft_open_args.stream = ftstream;
 343 
 344                     error = FT_Open_Face(scalerInfo->library,
 345                                          &ft_open_args,
 346                                          indexInCollection,
 347                                          &scalerInfo->face);
 348                     if (!error) {
 349                         scalerInfo->faceStream = ftstream;
 350                     }
 351                 }
 352                 if (error || scalerInfo->directBuffer == NULL) {
 353                     free(ftstream);
 354                 }
 355             }
 356         }
 357     }
 358 
 359     if (error) {
 360         FT_Done_FreeType(scalerInfo->library);
 361         if (scalerInfo->directBuffer != NULL) {
 362             (*env)->DeleteGlobalRef(env, scalerInfo->directBuffer);
 363         }
 364         if (scalerInfo->fontData != NULL)
 365             free(scalerInfo->fontData);
 366         free(scalerInfo);
 367         return 0;
 368     }
 369 
 370     return ptr_to_jlong(scalerInfo);
 371 }
 372 
 373 static double euclidianDistance(double a, double b) {
 374     if (a < 0) a=-a;
 375     if (b < 0) b=-b;
 376 
 377     if (a == 0) return b;
 378     if (b == 0) return a;
 379 
 380     return sqrt(a*a+b*b);
 381 }
 382 
 383 JNIEXPORT jlong JNICALL
 384 Java_sun_font_FreetypeFontScaler_createScalerContextNative(
 385         JNIEnv *env, jobject scaler, jlong pScaler, jdoubleArray matrix,
 386         jint aa, jint fm, jfloat boldness, jfloat italic) {
 387     double dmat[4], ptsz;
 388     FTScalerContext *context =
 389             (FTScalerContext*) calloc(1, sizeof(FTScalerContext));
 390     FTScalerInfo *scalerInfo =
 391              (FTScalerInfo*) jlong_to_ptr(pScaler);
 392 
 393     if (context == NULL) {
 394         invalidateJavaScaler(env, scaler, NULL);
 395         return (jlong) 0;
 396     }
 397     (*env)->GetDoubleArrayRegion(env, matrix, 0, 4, dmat);
 398     ptsz = euclidianDistance(dmat[2], dmat[3]); //i.e. y-size
 399     if (ptsz < 1.0) {
 400         //text can not be smaller than 1 point
 401         ptsz = 1.0;
 402     }
 403     context->ptsz = (int)(ptsz * 64);
 404     context->transform.xx =  FloatToFTFixed((float)dmat[0]/ptsz);
 405     context->transform.yx = -FloatToFTFixed((float)dmat[1]/ptsz);
 406     context->transform.xy = -FloatToFTFixed((float)dmat[2]/ptsz);
 407     context->transform.yy =  FloatToFTFixed((float)dmat[3]/ptsz);
 408     context->aaType = aa;
 409     context->fmType = fm;
 410 
 411     /* If using algorithmic styling, the base values are
 412      * boldness = 1.0, italic = 0.0.
 413      */
 414     context->doBold = (boldness != 1.0);
 415     context->doItalize = (italic != 0);
 416 
 417     /* freetype is very keen to use embedded bitmaps, even if it knows
 418      * there is a rotation or you asked for antialiasing.
 419      * In the rendering path we will check useSBits and disable
 420      * bitmaps unless it is set. And here we set it only if none
 421      * of the conditions invalidate using it.
 422      * Note that we allow embedded bitmaps for the LCD case.
 423      */
 424     if ((aa != TEXT_AA_ON) && (fm != TEXT_FM_ON) &&
 425         !context->doBold && !context->doItalize &&
 426         (context->transform.yx == 0) && (context->transform.xy == 0))
 427     {
 428         context->useSbits = 1;
 429     }
 430     return ptr_to_jlong(context);
 431 }
 432 
 433 static int setupFTContext(JNIEnv *env,
 434                           jobject font2D,
 435                           FTScalerInfo *scalerInfo,
 436                           FTScalerContext *context) {
 437     int errCode = 0;
 438 
 439     scalerInfo->env = env;
 440     scalerInfo->font2D = font2D;
 441 
 442     if (context != NULL) {
 443         FT_Set_Transform(scalerInfo->face, &context->transform, NULL);
 444 
 445         errCode = FT_Set_Char_Size(scalerInfo->face, 0, context->ptsz, 72, 72);
 446 
 447         if (errCode == 0) {
 448             errCode = FT_Activate_Size(scalerInfo->face->size);
 449         }
 450 
 451         FT_Library_SetLcdFilter(scalerInfo->library, FT_LCD_FILTER_DEFAULT);
 452     }
 453 
 454     return errCode;
 455 }
 456 
 457 /* ftsynth.c uses (0x10000, 0x0366A, 0x0, 0x10000) matrix to get oblique
 458    outline.  Therefore x coordinate will change by 0x0366A*y.
 459    Note that y coordinate does not change. These values are based on
 460    libfreetype version 2.9.1. */
 461 #define OBLIQUE_MODIFIER(y)  (context->doItalize ? ((y)*0x366A/0x10000) : 0)
 462 
 463 /* FT_GlyphSlot_Embolden (ftsynth.c) uses FT_MulFix(units_per_EM, y_scale) / 24
 464  * strength value when glyph format is FT_GLYPH_FORMAT_OUTLINE. This value has
 465  * been taken from libfreetype version 2.6 and remain valid at least up to
 466  * 2.9.1. */
 467 #define BOLD_MODIFIER(units_per_EM, y_scale) \
 468     (context->doBold ? FT_MulFix(units_per_EM, y_scale) / 24 : 0)
 469 
 470 /*
 471  * Class:     sun_font_FreetypeFontScaler
 472  * Method:    getFontMetricsNative
 473  * Signature: (Lsun/font/Font2D;J)Lsun/font/StrikeMetrics;
 474  */
 475 JNIEXPORT jobject JNICALL
 476 Java_sun_font_FreetypeFontScaler_getFontMetricsNative(
 477         JNIEnv *env, jobject scaler, jobject font2D,
 478         jlong pScalerContext, jlong pScaler) {
 479 
 480     jobject metrics;
 481     jfloat ax, ay, dx, dy, bx, by, lx, ly, mx, my;
 482     jfloat f0 = 0.0;
 483     FTScalerContext *context =
 484         (FTScalerContext*) jlong_to_ptr(pScalerContext);
 485     FTScalerInfo *scalerInfo =
 486              (FTScalerInfo*) jlong_to_ptr(pScaler);
 487 
 488     int errCode;
 489 
 490     if (isNullScalerContext(context) || scalerInfo == NULL) {
 491         return (*env)->NewObject(env,
 492                                  sunFontIDs.strikeMetricsClass,
 493                                  sunFontIDs.strikeMetricsCtr,
 494                                  f0, f0, f0, f0, f0, f0, f0, f0, f0, f0);
 495     }
 496 
 497     errCode = setupFTContext(env, font2D, scalerInfo, context);
 498 
 499     if (errCode) {
 500         metrics = (*env)->NewObject(env,
 501                                  sunFontIDs.strikeMetricsClass,
 502                                  sunFontIDs.strikeMetricsCtr,
 503                                  f0, f0, f0, f0, f0, f0, f0, f0, f0, f0);
 504         invalidateJavaScaler(env, scaler, scalerInfo);
 505         return metrics;
 506     }
 507 
 508     /* This is ugly and has to be reworked.
 509        Freetype provide means to add style to glyph but
 510        it seems there is no way to adjust metrics accordingly.
 511 
 512        So, we have to do adust them explicitly and stay consistent with what
 513        freetype does to outlines. */
 514 
 515 
 516     /**** Note: only some metrics are affected by styling ***/
 517 
 518     /* See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=657854 */
 519 #define FT_MulFixFloatShift6(a, b) (((float) (a)) * ((float) (b)) / 65536.0 / 64.0)
 520 
 521 #define contextAwareMetricsX(x, y) \
 522     (FTFixedToFloat(context->transform.xx) * (x) - \
 523      FTFixedToFloat(context->transform.xy) * (y))
 524 
 525 #define contextAwareMetricsY(x, y) \
 526     (-FTFixedToFloat(context->transform.yx) * (x) + \
 527      FTFixedToFloat(context->transform.yy) * (y))
 528 
 529     /*
 530      * See FreeType source code: src/base/ftobjs.c ft_recompute_scaled_metrics()
 531      * http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=1659
 532      */
 533     /* ascent */
 534     ax = 0;
 535     ay = -(jfloat) (FT_MulFixFloatShift6(
 536                        ((jlong) scalerInfo->face->ascender),
 537                        (jlong) scalerInfo->face->size->metrics.y_scale));
 538     /* descent */
 539     dx = 0;
 540     dy = -(jfloat) (FT_MulFixFloatShift6(
 541                        ((jlong) scalerInfo->face->descender),
 542                        (jlong) scalerInfo->face->size->metrics.y_scale));
 543     /* baseline */
 544     bx = by = 0;
 545 
 546     /* leading */
 547     lx = 0;
 548     ly = (jfloat) (FT_MulFixFloatShift6(
 549                       (jlong) scalerInfo->face->height,
 550                       (jlong) scalerInfo->face->size->metrics.y_scale))
 551                   + ay - dy;
 552     /* max advance */
 553     mx = (jfloat) FT26Dot6ToFloat(
 554                      scalerInfo->face->size->metrics.max_advance +
 555                      OBLIQUE_MODIFIER(scalerInfo->face->size->metrics.height) +
 556                      BOLD_MODIFIER(scalerInfo->face->units_per_EM,
 557                              scalerInfo->face->size->metrics.y_scale));
 558     my = 0;
 559 
 560     metrics = (*env)->NewObject(env,
 561         sunFontIDs.strikeMetricsClass,
 562         sunFontIDs.strikeMetricsCtr,
 563         contextAwareMetricsX(ax, ay), contextAwareMetricsY(ax, ay),
 564         contextAwareMetricsX(dx, dy), contextAwareMetricsY(dx, dy),
 565         bx, by,
 566         contextAwareMetricsX(lx, ly), contextAwareMetricsY(lx, ly),
 567         contextAwareMetricsX(mx, my), contextAwareMetricsY(mx, my));
 568 
 569     return metrics;
 570 }
 571 
 572 /*
 573  * Class:     sun_font_FreetypeFontScaler
 574  * Method:    getGlyphAdvanceNative
 575  * Signature: (Lsun/font/Font2D;JI)F
 576  */
 577 JNIEXPORT jfloat JNICALL
 578 Java_sun_font_FreetypeFontScaler_getGlyphAdvanceNative(
 579         JNIEnv *env, jobject scaler, jobject font2D,
 580         jlong pScalerContext, jlong pScaler, jint glyphCode) {
 581 
 582    /* This method is rarely used because requests for metrics are usually
 583       coupled with request for bitmap and to large extend work can be reused
 584       (to find out metrics we need to hint glyph).
 585       So, we typically go through getGlyphImage code path.
 586 
 587       For initial freetype implementation we delegate
 588       all work to getGlyphImage but drop result image.
 589       This is waste of work related to scan conversion and conversion from
 590       freetype format to our format but for now this seems to be ok.
 591 
 592       NB: investigate performance benefits of refactoring code
 593       to avoid unnecesary work with bitmaps. */
 594 
 595     GlyphInfo *info;
 596     jfloat advance;
 597     jlong image;
 598 
 599     image = Java_sun_font_FreetypeFontScaler_getGlyphImageNative(
 600                  env, scaler, font2D, pScalerContext, pScaler, glyphCode);
 601     info = (GlyphInfo*) jlong_to_ptr(image);
 602 
 603     advance = info->advanceX;
 604 
 605     free(info);
 606 
 607     return advance;
 608 }
 609 
 610 /*
 611  * Class:     sun_font_FreetypeFontScaler
 612  * Method:    getGlyphMetricsNative
 613  * Signature: (Lsun/font/Font2D;JILjava/awt/geom/Point2D/Float;)V
 614  */
 615 JNIEXPORT void JNICALL
 616 Java_sun_font_FreetypeFontScaler_getGlyphMetricsNative(
 617         JNIEnv *env, jobject scaler, jobject font2D, jlong pScalerContext,
 618         jlong pScaler, jint glyphCode, jobject metrics) {
 619 
 620      /* As initial implementation we delegate all work to getGlyphImage
 621         but drop result image. This is clearly waste of resorces.
 622 
 623         TODO: investigate performance benefits of refactoring code
 624               by avoiding bitmap generation and conversion from FT
 625               bitmap format. */
 626      GlyphInfo *info;
 627 
 628      jlong image = Java_sun_font_FreetypeFontScaler_getGlyphImageNative(
 629                                  env, scaler, font2D,
 630                                  pScalerContext, pScaler, glyphCode);
 631      info = (GlyphInfo*) jlong_to_ptr(image);
 632 
 633      (*env)->SetFloatField(env, metrics, sunFontIDs.xFID, info->advanceX);
 634      (*env)->SetFloatField(env, metrics, sunFontIDs.yFID, info->advanceY);
 635 
 636      free(info);
 637 }
 638 
 639 
 640 static GlyphInfo* getNullGlyphImage() {
 641     GlyphInfo *glyphInfo =  (GlyphInfo*) calloc(1, sizeof(GlyphInfo));
 642     return glyphInfo;
 643 }
 644 
 645 static void CopyBW2Grey8(const void* srcImage, int srcRowBytes,
 646                          void* dstImage, int dstRowBytes,
 647                          int width, int height) {
 648     const UInt8* srcRow = (UInt8*)srcImage;
 649     UInt8* dstRow = (UInt8*)dstImage;
 650     int wholeByteCount = width >> 3;
 651     int remainingBitsCount = width & 7;
 652     int i, j;
 653 
 654     while (height--) {
 655         const UInt8* src8 = srcRow;
 656         UInt8* dstByte = dstRow;
 657         unsigned srcValue;
 658 
 659         srcRow += srcRowBytes;
 660         dstRow += dstRowBytes;
 661 
 662         for (i = 0; i < wholeByteCount; i++) {
 663             srcValue = *src8++;
 664             for (j = 0; j < 8; j++) {
 665                 *dstByte++ = (srcValue & 0x80) ? 0xFF : 0;
 666                 srcValue <<= 1;
 667             }
 668         }
 669         if (remainingBitsCount) {
 670             srcValue = *src8;
 671             for (j = 0; j < remainingBitsCount; j++) {
 672                 *dstByte++ = (srcValue & 0x80) ? 0xFF : 0;
 673                 srcValue <<= 1;
 674             }
 675         }
 676     }
 677 }
 678 
 679 #define Grey4ToAlpha255(value) (((value) << 4) + ((value) >> 3))
 680 
 681 static void CopyGrey4ToGrey8(const void* srcImage, int srcRowBytes,
 682                 void* dstImage, int dstRowBytes, int width, int height) {
 683      const UInt8* srcRow = (UInt8*) srcImage;
 684      UInt8* dstRow = (UInt8*) dstImage;
 685      int i;
 686 
 687      while (height--) {
 688          const UInt8* src8 = srcRow;
 689          UInt8* dstByte = dstRow;
 690          unsigned srcValue;
 691 
 692          srcRow += srcRowBytes;
 693          dstRow += dstRowBytes;
 694 
 695          for (i = 0; i < width; i++) {
 696              srcValue = *src8++;
 697              *dstByte++ = Grey4ToAlpha255(srcValue & 0x0f);
 698              *dstByte++ = Grey4ToAlpha255(srcValue >> 4);
 699          }
 700      }
 701 }
 702 
 703 /* We need it because FT rows are often padded to 4 byte boundaries
 704     and our internal format is not padded */
 705 static void CopyFTSubpixelToSubpixel(const void* srcImage, int srcRowBytes,
 706                                      void* dstImage, int dstRowBytes,
 707                                      int width, int height) {
 708     unsigned char *srcRow = (unsigned char *) srcImage;
 709     unsigned char *dstRow = (unsigned char *) dstImage;
 710 
 711     while (height--) {
 712         memcpy(dstRow, srcRow, width);
 713         srcRow += srcRowBytes;
 714         dstRow += dstRowBytes;
 715     }
 716 }
 717 
 718 /* We need it because FT rows are often padded to 4 byte boundaries
 719    and our internal format is not padded */
 720 static void CopyFTSubpixelVToSubpixel(const void* srcImage, int srcRowBytes,
 721                                       void* dstImage, int dstRowBytes,
 722                                       int width, int height) {
 723     unsigned char *srcRow = (unsigned char *) srcImage, *srcByte;
 724     unsigned char *dstRow = (unsigned char *) dstImage, *dstByte;
 725     int i;
 726 
 727     while (height > 0) {
 728         srcByte = srcRow;
 729         dstByte = dstRow;
 730         for (i = 0; i < width; i++) {
 731             *dstByte++ = *srcByte;
 732             *dstByte++ = *(srcByte + srcRowBytes);
 733             *dstByte++ = *(srcByte + 2*srcRowBytes);
 734             srcByte++;
 735         }
 736         srcRow += 3*srcRowBytes;
 737         dstRow += dstRowBytes;
 738         height -= 3;
 739     }
 740 }
 741 
 742 
 743 /*
 744  * Class:     sun_font_FreetypeFontScaler
 745  * Method:    getGlyphImageNative
 746  * Signature: (Lsun/font/Font2D;JI)J
 747  */
 748 JNIEXPORT jlong JNICALL
 749 Java_sun_font_FreetypeFontScaler_getGlyphImageNative(
 750         JNIEnv *env, jobject scaler, jobject font2D,
 751         jlong pScalerContext, jlong pScaler, jint glyphCode) {
 752 
 753     int error, imageSize;
 754     UInt16 width, height;
 755     GlyphInfo *glyphInfo;
 756     int renderFlags = FT_LOAD_DEFAULT, target;
 757     FT_GlyphSlot ftglyph;
 758 
 759     FTScalerContext* context =
 760         (FTScalerContext*) jlong_to_ptr(pScalerContext);
 761     FTScalerInfo *scalerInfo =
 762              (FTScalerInfo*) jlong_to_ptr(pScaler);
 763 
 764     if (isNullScalerContext(context) || scalerInfo == NULL) {
 765         return ptr_to_jlong(getNullGlyphImage());
 766     }
 767 
 768     error = setupFTContext(env, font2D, scalerInfo, context);
 769     if (error) {
 770         invalidateJavaScaler(env, scaler, scalerInfo);
 771         return ptr_to_jlong(getNullGlyphImage());
 772     }
 773 
 774     if (!context->useSbits) {
 775         renderFlags |= FT_LOAD_NO_BITMAP;
 776     }
 777 
 778     /* NB: in case of non identity transform
 779      we might also prefer to disable transform before hinting,
 780      and apply it explicitly after hinting is performed.
 781      Or we can disable hinting. */
 782 
 783     /* select appropriate hinting mode */
 784     if (context->aaType == TEXT_AA_OFF) {
 785         target = FT_LOAD_TARGET_MONO;
 786     } else if (context->aaType == TEXT_AA_ON) {
 787         target = FT_LOAD_TARGET_NORMAL;
 788     } else if (context->aaType == TEXT_AA_LCD_HRGB ||
 789                context->aaType == TEXT_AA_LCD_HBGR) {
 790         target = FT_LOAD_TARGET_LCD;
 791     } else {
 792         target = FT_LOAD_TARGET_LCD_V;
 793     }
 794     renderFlags |= target;
 795 
 796     error = FT_Load_Glyph(scalerInfo->face, glyphCode, renderFlags);
 797     if (error) {
 798         //do not destroy scaler yet.
 799         //this can be problem of particular context (e.g. with bad transform)
 800         return ptr_to_jlong(getNullGlyphImage());
 801     }
 802 
 803     ftglyph = scalerInfo->face->glyph;
 804 
 805     /* apply styles */
 806     if (context->doBold) { /* if bold style */
 807         FT_GlyphSlot_Embolden(ftglyph);
 808     }
 809     if (context->doItalize) { /* if oblique */
 810         FT_GlyphSlot_Oblique(ftglyph);
 811     }
 812 
 813     /* generate bitmap if it is not done yet
 814      e.g. if algorithmic styling is performed and style was added to outline */
 815     if (ftglyph->format == FT_GLYPH_FORMAT_OUTLINE) {
 816         error = FT_Render_Glyph(ftglyph, FT_LOAD_TARGET_MODE(target));
 817         if (error != 0) {
 818             return ptr_to_jlong(getNullGlyphImage());
 819         }
 820     }
 821 
 822     width  = (UInt16) ftglyph->bitmap.width;
 823     height = (UInt16) ftglyph->bitmap.rows;
 824 
 825     imageSize = width*height;
 826     glyphInfo = (GlyphInfo*) malloc(sizeof(GlyphInfo) + imageSize);
 827     if (glyphInfo == NULL) {
 828         glyphInfo = getNullGlyphImage();
 829         return ptr_to_jlong(glyphInfo);
 830     }
 831     glyphInfo->cellInfo  = NULL;
 832     glyphInfo->managed   = UNMANAGED_GLYPH;
 833     glyphInfo->rowBytes  = width;
 834     glyphInfo->width     = width;
 835     glyphInfo->height    = height;
 836     glyphInfo->topLeftX  = (float)  ftglyph->bitmap_left;
 837     glyphInfo->topLeftY  = (float) -ftglyph->bitmap_top;
 838 
 839     if (ftglyph->bitmap.pixel_mode ==  FT_PIXEL_MODE_LCD) {
 840         glyphInfo->width = width/3;
 841     } else if (ftglyph->bitmap.pixel_mode ==  FT_PIXEL_MODE_LCD_V) {
 842         glyphInfo->height = glyphInfo->height/3;
 843     }
 844 
 845     if (context->fmType == TEXT_FM_ON) {
 846         double advh = FTFixedToFloat(ftglyph->linearHoriAdvance);
 847         glyphInfo->advanceX =
 848             (float) (advh * FTFixedToFloat(context->transform.xx));
 849         glyphInfo->advanceY =
 850             (float) (advh * FTFixedToFloat(context->transform.xy));
 851     } else {
 852         if (!ftglyph->advance.y) {
 853             glyphInfo->advanceX =
 854                 (float) FT26Dot6ToInt(ftglyph->advance.x);
 855             glyphInfo->advanceY = 0;
 856         } else if (!ftglyph->advance.x) {
 857             glyphInfo->advanceX = 0;
 858             glyphInfo->advanceY =
 859                 (float) FT26Dot6ToInt(-ftglyph->advance.y);
 860         } else {
 861             glyphInfo->advanceX = FT26Dot6ToFloat(ftglyph->advance.x);
 862             glyphInfo->advanceY = FT26Dot6ToFloat(-ftglyph->advance.y);
 863         }
 864     }
 865 
 866     if (imageSize == 0) {
 867         glyphInfo->image = NULL;
 868     } else {
 869         glyphInfo->image = (unsigned char*) glyphInfo + sizeof(GlyphInfo);
 870         //convert result to output format
 871         //output format is either 3 bytes per pixel (for subpixel modes)
 872         // or 1 byte per pixel for AA and B&W
 873         if (ftglyph->bitmap.pixel_mode ==  FT_PIXEL_MODE_MONO) {
 874             /* convert from 8 pixels per byte to 1 byte per pixel */
 875             CopyBW2Grey8(ftglyph->bitmap.buffer,
 876                          ftglyph->bitmap.pitch,
 877                          (void *) glyphInfo->image,
 878                          width,
 879                          width,
 880                          height);
 881         } else if (ftglyph->bitmap.pixel_mode ==  FT_PIXEL_MODE_GRAY) {
 882             /* byte per pixel to byte per pixel => just copy */
 883             memcpy(glyphInfo->image, ftglyph->bitmap.buffer, imageSize);
 884         } else if (ftglyph->bitmap.pixel_mode ==  FT_PIXEL_MODE_GRAY4) {
 885             /* 4 bits per pixel to byte per pixel */
 886             CopyGrey4ToGrey8(ftglyph->bitmap.buffer,
 887                              ftglyph->bitmap.pitch,
 888                              (void *) glyphInfo->image,
 889                              width,
 890                              width,
 891                              height);
 892         } else if (ftglyph->bitmap.pixel_mode ==  FT_PIXEL_MODE_LCD) {
 893             /* 3 bytes per pixel to 3 bytes per pixel */
 894             CopyFTSubpixelToSubpixel(ftglyph->bitmap.buffer,
 895                                      ftglyph->bitmap.pitch,
 896                                      (void *) glyphInfo->image,
 897                                      width,
 898                                      width,
 899                                      height);
 900         } else if (ftglyph->bitmap.pixel_mode ==  FT_PIXEL_MODE_LCD_V) {
 901             /* 3 bytes per pixel to 3 bytes per pixel */
 902             CopyFTSubpixelVToSubpixel(ftglyph->bitmap.buffer,
 903                                       ftglyph->bitmap.pitch,
 904                                       (void *) glyphInfo->image,
 905                                       width*3,
 906                                       width,
 907                                       height);
 908             glyphInfo->rowBytes *=3;
 909         } else {
 910             free(glyphInfo);
 911             glyphInfo = getNullGlyphImage();
 912         }
 913     }
 914 
 915     return ptr_to_jlong(glyphInfo);
 916 }
 917 
 918 /*
 919  * Class:     sun_font_FreetypeFontScaler
 920  * Method:    disposeNativeScaler
 921  * Signature: (J)V
 922  */
 923 JNIEXPORT void JNICALL
 924 Java_sun_font_FreetypeFontScaler_disposeNativeScaler(
 925         JNIEnv *env, jobject scaler, jobject font2D, jlong pScaler) {
 926     FTScalerInfo* scalerInfo = (FTScalerInfo *) jlong_to_ptr(pScaler);
 927 
 928     /* Freetype functions *may* cause callback to java
 929        that can use cached values. Make sure our cache is up to date.
 930        NB: scaler context is not important at this point, can use NULL. */
 931     int errCode = setupFTContext(env, font2D, scalerInfo, NULL);
 932     if (errCode) {
 933         return;
 934     }
 935 
 936     freeNativeResources(env, scalerInfo);
 937 }
 938 
 939 /*
 940  * Class:     sun_font_FreetypeFontScaler
 941  * Method:    getNumGlyphsNative
 942  * Signature: ()I
 943  */
 944 JNIEXPORT jint JNICALL
 945 Java_sun_font_FreetypeFontScaler_getNumGlyphsNative(
 946         JNIEnv *env, jobject scaler, jlong pScaler) {
 947     FTScalerInfo* scalerInfo = (FTScalerInfo *) jlong_to_ptr(pScaler);
 948 
 949     if (scalerInfo == NULL || scalerInfo->face == NULL) { /* bad/null scaler */
 950         /* null scaler can render 1 glyph - "missing glyph" with code 0
 951            (all glyph codes requested by user are mapped to code 0 at
 952            validation step) */
 953         invalidateJavaScaler(env, scaler, scalerInfo);
 954         return (jint) 1;
 955     }
 956 
 957     return (jint) scalerInfo->face->num_glyphs;
 958 }
 959 
 960 /*
 961  * Class:     sun_font_FreetypeFontScaler
 962  * Method:    getMissingGlyphCodeNative
 963  * Signature: ()I
 964  */
 965 JNIEXPORT jint JNICALL
 966 Java_sun_font_FreetypeFontScaler_getMissingGlyphCodeNative(
 967         JNIEnv *env, jobject scaler, jlong pScaler) {
 968 
 969     /* Is it always 0 for freetype? */
 970     return 0;
 971 }
 972 
 973 /*
 974  * Class:     sun_font_FreetypeFontScaler
 975  * Method:    getGlyphCodeNative
 976  * Signature: (C)I
 977  */
 978 JNIEXPORT jint JNICALL
 979 Java_sun_font_FreetypeFontScaler_getGlyphCodeNative(
 980         JNIEnv *env, jobject scaler,
 981         jobject font2D, jlong pScaler, jchar charCode) {
 982 
 983     FTScalerInfo* scalerInfo = (FTScalerInfo *) jlong_to_ptr(pScaler);
 984     int errCode;
 985 
 986     if (scaler == NULL || scalerInfo->face == NULL) { /* bad/null scaler */
 987         invalidateJavaScaler(env, scaler, scalerInfo);
 988         return 0;
 989     }
 990 
 991     /* Freetype functions *may* cause callback to java
 992        that can use cached values. Make sure our cache is up to date.
 993        Scaler context is not important here, can use NULL. */
 994     errCode = setupFTContext(env, font2D, scalerInfo, NULL);
 995     if (errCode) {
 996         return 0;
 997     }
 998 
 999     return FT_Get_Char_Index(scalerInfo->face, charCode);
1000 }
1001 
1002 
1003 #define FloatToF26Dot6(x) ((unsigned int) ((x)*64))
1004 
1005 static FT_Outline* getFTOutline(JNIEnv* env, jobject font2D,
1006         FTScalerContext *context, FTScalerInfo* scalerInfo,
1007         jint glyphCode, jfloat xpos, jfloat ypos) {
1008     int renderFlags;
1009     FT_Error error;
1010     FT_GlyphSlot ftglyph;
1011 
1012     if (glyphCode >= INVISIBLE_GLYPHS ||
1013             isNullScalerContext(context) || scalerInfo == NULL) {
1014         return NULL;
1015     }
1016 
1017     error = setupFTContext(env, font2D, scalerInfo, context);
1018     if (error) {
1019         return NULL;
1020     }
1021 
1022     renderFlags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
1023 
1024     error = FT_Load_Glyph(scalerInfo->face, glyphCode, renderFlags);
1025     if (error) {
1026         return NULL;
1027     }
1028 
1029     ftglyph = scalerInfo->face->glyph;
1030 
1031     /* apply styles */
1032     if (context->doBold) { /* if bold style */
1033         FT_GlyphSlot_Embolden(ftglyph);
1034     }
1035     if (context->doItalize) { /* if oblique */
1036         FT_GlyphSlot_Oblique(ftglyph);
1037     }
1038 
1039     FT_Outline_Translate(&ftglyph->outline,
1040                          FloatToF26Dot6(xpos),
1041                          -FloatToF26Dot6(ypos));
1042 
1043     return &ftglyph->outline;
1044 }
1045 
1046 #define F26Dot6ToFloat(n) (((float)(n))/((float) 64))
1047 
1048 /* Types of GeneralPath segments.
1049    TODO: pull constants from other place? */
1050 
1051 #define SEG_UNKNOWN -1
1052 #define SEG_MOVETO   0
1053 #define SEG_LINETO   1
1054 #define SEG_QUADTO   2
1055 #define SEG_CUBICTO  3
1056 #define SEG_CLOSE    4
1057 
1058 #define WIND_NON_ZERO 0
1059 #define WIND_EVEN_ODD 1
1060 
1061 /* Placeholder to accumulate GeneralPath data */
1062 typedef struct {
1063     jint numTypes;
1064     jint numCoords;
1065     jint lenTypes;
1066     jint lenCoords;
1067     jint wr;
1068     jbyte* pointTypes;
1069     jfloat* pointCoords;
1070 } GPData;
1071 
1072 /* returns 0 on failure */
1073 static int allocateSpaceForGP(GPData* gpdata, int npoints, int ncontours) {
1074     int maxTypes, maxCoords;
1075 
1076     /* we may have up to N intermediate points per contour
1077        (and for each point can actually cause new curve to be generated)
1078        In addition we can also have 2 extra point per outline.
1079      */
1080     maxTypes  = 2*npoints  + 2*ncontours;
1081     maxCoords = 4*(npoints + 2*ncontours); //we may need to insert
1082                                            //up to n-1 intermediate points
1083 
1084     /* first usage - allocate space and intialize all fields */
1085     if (gpdata->pointTypes == NULL || gpdata->pointCoords == NULL) {
1086         gpdata->lenTypes  = maxTypes;
1087         gpdata->lenCoords = maxCoords;
1088         gpdata->pointTypes  = (jbyte*)
1089              malloc(gpdata->lenTypes*sizeof(jbyte));
1090         gpdata->pointCoords = (jfloat*)
1091              malloc(gpdata->lenCoords*sizeof(jfloat));
1092         gpdata->numTypes = 0;
1093         gpdata->numCoords = 0;
1094         gpdata->wr = WIND_NON_ZERO; /* By default, outlines are filled
1095                                        using the non-zero winding rule. */
1096     } else {
1097         /* do we have enough space? */
1098         if (gpdata->lenTypes - gpdata->numTypes < maxTypes) {
1099             gpdata->lenTypes  += maxTypes;
1100             gpdata->pointTypes  = (jbyte*)
1101               realloc(gpdata->pointTypes, gpdata->lenTypes*sizeof(jbyte));
1102         }
1103 
1104         if (gpdata->lenCoords - gpdata->numCoords < maxCoords) {
1105             gpdata->lenCoords += maxCoords;
1106             gpdata->pointCoords = (jfloat*)
1107               realloc(gpdata->pointCoords, gpdata->lenCoords*sizeof(jfloat));
1108         }
1109     }
1110 
1111     /* failure if any of mallocs failed */
1112     if (gpdata->pointTypes == NULL ||  gpdata->pointCoords == NULL)
1113         return 0;
1114     else
1115         return 1;
1116 }
1117 
1118 static void addSeg(GPData *gp, jbyte type) {
1119     gp->pointTypes[gp->numTypes++] = type;
1120 }
1121 
1122 static void addCoords(GPData *gp, FT_Vector *p) {
1123     gp->pointCoords[gp->numCoords++] =  F26Dot6ToFloat(p->x);
1124     gp->pointCoords[gp->numCoords++] = -F26Dot6ToFloat(p->y);
1125 }
1126 
1127 static int moveTo(FT_Vector *to, GPData *gp) {
1128     if (gp->numCoords)
1129         addSeg(gp, SEG_CLOSE);
1130     addCoords(gp, to);
1131     addSeg(gp, SEG_MOVETO);
1132     return FT_Err_Ok;
1133 }
1134 
1135 static int lineTo(FT_Vector *to, GPData *gp) {
1136     addCoords(gp, to);
1137     addSeg(gp, SEG_LINETO);
1138     return FT_Err_Ok;
1139 }
1140 
1141 static int conicTo(FT_Vector *control, FT_Vector *to, GPData *gp) {
1142     addCoords(gp, control);
1143     addCoords(gp, to);
1144     addSeg(gp, SEG_QUADTO);
1145     return FT_Err_Ok;
1146 }
1147 
1148 static int cubicTo(FT_Vector *control1,
1149                    FT_Vector *control2,
1150                    FT_Vector *to,
1151                    GPData    *gp) {
1152     addCoords(gp, control1);
1153     addCoords(gp, control2);
1154     addCoords(gp, to);
1155     addSeg(gp, SEG_CUBICTO);
1156     return FT_Err_Ok;
1157 }
1158 
1159 static void addToGP(GPData* gpdata, FT_Outline*outline) {
1160     static const FT_Outline_Funcs outline_funcs = {
1161         (FT_Outline_MoveToFunc) moveTo,
1162         (FT_Outline_LineToFunc) lineTo,
1163         (FT_Outline_ConicToFunc) conicTo,
1164         (FT_Outline_CubicToFunc) cubicTo,
1165         0, /* shift */
1166         0, /* delta */
1167     };
1168 
1169     FT_Outline_Decompose(outline, &outline_funcs, gpdata);
1170     if (gpdata->numCoords)
1171         addSeg(gpdata, SEG_CLOSE);
1172 
1173     /* If set to 1, the outline will be filled using the even-odd fill rule */
1174     if (outline->flags & FT_OUTLINE_EVEN_ODD_FILL) {
1175         gpdata->wr = WIND_EVEN_ODD;
1176     }
1177 }
1178 
1179 static void freeGP(GPData* gpdata) {
1180     if (gpdata->pointCoords != NULL) {
1181         free(gpdata->pointCoords);
1182         gpdata->pointCoords = NULL;
1183         gpdata->numCoords = 0;
1184         gpdata->lenCoords = 0;
1185     }
1186     if (gpdata->pointTypes != NULL) {
1187         free(gpdata->pointTypes);
1188         gpdata->pointTypes = NULL;
1189         gpdata->numTypes = 0;
1190         gpdata->lenTypes = 0;
1191     }
1192 }
1193 
1194 static jobject getGlyphGeneralPath(JNIEnv* env, jobject font2D,
1195         FTScalerContext *context, FTScalerInfo *scalerInfo,
1196         jint glyphCode, jfloat xpos, jfloat ypos) {
1197 
1198     FT_Outline* outline;
1199     jobject gp = NULL;
1200     jbyteArray types;
1201     jfloatArray coords;
1202     GPData gpdata;
1203 
1204     outline = getFTOutline(env, font2D, context, scalerInfo,
1205                            glyphCode, xpos, ypos);
1206 
1207     if (outline == NULL || outline->n_points == 0) {
1208         return gp;
1209     }
1210 
1211     gpdata.pointTypes  = NULL;
1212     gpdata.pointCoords = NULL;
1213     if (!allocateSpaceForGP(&gpdata, outline->n_points, outline->n_contours)) {
1214         return gp;
1215     }
1216 
1217     addToGP(&gpdata, outline);
1218 
1219     types  = (*env)->NewByteArray(env, gpdata.numTypes);
1220     coords = (*env)->NewFloatArray(env, gpdata.numCoords);
1221 
1222     if (types && coords) {
1223         (*env)->SetByteArrayRegion(env, types, 0,
1224                                    gpdata.numTypes,
1225                                    gpdata.pointTypes);
1226         (*env)->SetFloatArrayRegion(env, coords, 0,
1227                                     gpdata.numCoords,
1228                                     gpdata.pointCoords);
1229         gp = (*env)->NewObject(env,
1230                                sunFontIDs.gpClass,
1231                                sunFontIDs.gpCtr,
1232                                gpdata.wr,
1233                                types,
1234                                gpdata.numTypes,
1235                                coords,
1236                                gpdata.numCoords);
1237     }
1238 
1239     freeGP(&gpdata);
1240 
1241     return gp;
1242 }
1243 
1244 /*
1245  * Class:     sun_font_FreetypeFontScaler
1246  * Method:    getGlyphOutlineNative
1247  * Signature: (Lsun/font/Font2D;JIFF)Ljava/awt/geom/GeneralPath;
1248  */
1249 JNIEXPORT jobject JNICALL
1250 Java_sun_font_FreetypeFontScaler_getGlyphOutlineNative(
1251       JNIEnv *env, jobject scaler, jobject font2D, jlong pScalerContext,
1252       jlong pScaler, jint glyphCode, jfloat xpos, jfloat ypos) {
1253 
1254     FTScalerContext *context =
1255          (FTScalerContext*) jlong_to_ptr(pScalerContext);
1256     FTScalerInfo* scalerInfo = (FTScalerInfo *) jlong_to_ptr(pScaler);
1257 
1258     jobject gp = getGlyphGeneralPath(env,
1259                                font2D,
1260                                context,
1261                                scalerInfo,
1262                                glyphCode,
1263                                xpos,
1264                                ypos);
1265     if (gp == NULL) { /* can be legal */
1266         gp = (*env)->NewObject(env,
1267                                sunFontIDs.gpClass,
1268                                sunFontIDs.gpCtrEmpty);
1269     }
1270     return gp;
1271 }
1272 
1273 /*
1274  * Class:     sun_font_FreetypeFontScaler
1275  * Method:    getGlyphOutlineBoundsNative
1276  * Signature: (Lsun/font/Font2D;JI)Ljava/awt/geom/Rectangle2D/Float;
1277  */
1278 JNIEXPORT jobject JNICALL
1279 Java_sun_font_FreetypeFontScaler_getGlyphOutlineBoundsNative(
1280         JNIEnv *env, jobject scaler, jobject font2D,
1281         jlong pScalerContext, jlong pScaler, jint glyphCode) {
1282 
1283     FT_Outline *outline;
1284     FT_BBox bbox;
1285     int error;
1286     jobject bounds;
1287 
1288     FTScalerContext *context =
1289          (FTScalerContext*) jlong_to_ptr(pScalerContext);
1290     FTScalerInfo* scalerInfo = (FTScalerInfo *) jlong_to_ptr(pScaler);
1291 
1292     outline = getFTOutline(env, font2D, context, scalerInfo, glyphCode, 0, 0);
1293     if (outline == NULL || outline->n_points == 0) {
1294         /* it is legal case, e.g. invisible glyph */
1295         bounds = (*env)->NewObject(env,
1296                                  sunFontIDs.rect2DFloatClass,
1297                                  sunFontIDs.rect2DFloatCtr);
1298         return bounds;
1299     }
1300 
1301     error = FT_Outline_Get_BBox(outline, &bbox);
1302 
1303     //convert bbox
1304     if (error || bbox.xMin >= bbox.xMax || bbox.yMin >= bbox.yMax) {
1305         bounds = (*env)->NewObject(env,
1306                                    sunFontIDs.rect2DFloatClass,
1307                                    sunFontIDs.rect2DFloatCtr);
1308     } else {
1309         bounds = (*env)->NewObject(env,
1310                                    sunFontIDs.rect2DFloatClass,
1311                                    sunFontIDs.rect2DFloatCtr4,
1312                                    F26Dot6ToFloat(bbox.xMin),
1313                                    F26Dot6ToFloat(-bbox.yMax),
1314                                    F26Dot6ToFloat(bbox.xMax-bbox.xMin),
1315                                    F26Dot6ToFloat(bbox.yMax-bbox.yMin));
1316     }
1317 
1318     return bounds;
1319 }
1320 
1321 /*
1322  * Class:     sun_font_FreetypeFontScaler
1323  * Method:    getGlyphVectorOutlineNative
1324  * Signature: (Lsun/font/Font2D;J[IIFF)Ljava/awt/geom/GeneralPath;
1325  */
1326 JNIEXPORT jobject
1327 JNICALL
1328 Java_sun_font_FreetypeFontScaler_getGlyphVectorOutlineNative(
1329         JNIEnv *env, jobject scaler, jobject font2D,
1330         jlong pScalerContext, jlong pScaler,
1331         jintArray glyphArray, jint numGlyphs, jfloat xpos, jfloat ypos) {
1332 
1333     FT_Outline* outline;
1334     jobject gp = NULL;
1335     jbyteArray types;
1336     jfloatArray coords;
1337     GPData gpdata;
1338     int i;
1339     jint *glyphs;
1340 
1341     FTScalerContext *context =
1342          (FTScalerContext*) jlong_to_ptr(pScalerContext);
1343     FTScalerInfo *scalerInfo =
1344              (FTScalerInfo*) jlong_to_ptr(pScaler);
1345 
1346     glyphs = NULL;
1347     if (numGlyphs > 0 && 0xffffffffu / sizeof(jint) >= numGlyphs) {
1348         glyphs = (jint*) malloc(numGlyphs*sizeof(jint));
1349     }
1350     if (glyphs == NULL) {
1351         // We reach here if:
1352         // 1. numGlyphs <= 0,
1353         // 2. overflow check failed, or
1354         // 3. malloc failed.
1355         gp = (*env)->NewObject(env, sunFontIDs.gpClass, sunFontIDs.gpCtrEmpty);
1356         return gp;
1357     }
1358 
1359     (*env)->GetIntArrayRegion(env, glyphArray, 0, numGlyphs, glyphs);
1360 
1361     gpdata.numCoords = 0;
1362     for (i=0; i<numGlyphs;i++) {
1363         if (glyphs[i] >= INVISIBLE_GLYPHS) {
1364             continue;
1365         }
1366         outline = getFTOutline(env,
1367                                font2D,
1368                                context,
1369                                scalerInfo,
1370                                glyphs[i],
1371                                xpos, ypos);
1372 
1373         if (outline == NULL || outline->n_points == 0) {
1374             continue;
1375         }
1376 
1377         gpdata.pointTypes  = NULL;
1378         gpdata.pointCoords = NULL;
1379         if (!allocateSpaceForGP(&gpdata, outline->n_points,
1380                                 outline->n_contours)) {
1381             break;
1382         }
1383 
1384         addToGP(&gpdata, outline);
1385     }
1386     free(glyphs);
1387 
1388     if (gpdata.numCoords != 0) {
1389       types = (*env)->NewByteArray(env, gpdata.numTypes);
1390       coords = (*env)->NewFloatArray(env, gpdata.numCoords);
1391 
1392       if (types && coords) {
1393         (*env)->SetByteArrayRegion(env, types, 0,
1394                                    gpdata.numTypes, gpdata.pointTypes);
1395         (*env)->SetFloatArrayRegion(env, coords, 0,
1396                                     gpdata.numCoords, gpdata.pointCoords);
1397 
1398         gp=(*env)->NewObject(env,
1399                              sunFontIDs.gpClass,
1400                              sunFontIDs.gpCtr,
1401                              gpdata.wr,
1402                              types,
1403                              gpdata.numTypes,
1404                              coords,
1405                              gpdata.numCoords);
1406         return gp;
1407       }
1408     }
1409     return (*env)->NewObject(env, sunFontIDs.gpClass, sunFontIDs.gpCtrEmpty);
1410 }
1411 
1412 JNIEXPORT jlong JNICALL
1413 Java_sun_font_FreetypeFontScaler_getUnitsPerEMNative(
1414         JNIEnv *env, jobject scaler, jlong pScaler) {
1415 
1416     FTScalerInfo *s = (FTScalerInfo* ) jlong_to_ptr(pScaler);
1417 
1418     /* Freetype doc says:
1419      The number of font units per EM square for this face.
1420      This is typically 2048 for TrueType fonts, and 1000 for Type 1 fonts.
1421      Only relevant for scalable formats.
1422      However, layout engine might be not tested with anything but 2048.
1423 
1424      NB: test it! */
1425     if (s != NULL) {
1426         return s->face->units_per_EM;
1427     }
1428     return 2048;
1429 }
1430 
1431 /* This native method is called by the OpenType layout engine. */
1432 JNIEXPORT jobject JNICALL
1433 Java_sun_font_FreetypeFontScaler_getGlyphPointNative(
1434         JNIEnv *env, jobject scaler, jobject font2D, jlong pScalerContext,
1435         jlong pScaler, jint glyphCode, jint pointNumber) {
1436 
1437     FT_Outline* outline;
1438     jobject point = NULL;
1439     jfloat x=0, y=0;
1440     FTScalerContext *context =
1441          (FTScalerContext*) jlong_to_ptr(pScalerContext);
1442     FTScalerInfo *scalerInfo = (FTScalerInfo*) jlong_to_ptr(pScaler);
1443 
1444     outline = getFTOutline(env, font2D, context, scalerInfo, glyphCode, 0, 0);
1445 
1446     if (outline != NULL && outline->n_points > pointNumber) {
1447         x =  F26Dot6ToFloat(outline->points[pointNumber].x);
1448         y = -F26Dot6ToFloat(outline->points[pointNumber].y);
1449     }
1450 
1451     return (*env)->NewObject(env, sunFontIDs.pt2DFloatClass,
1452                              sunFontIDs.pt2DFloatCtr, x, y);
1453 }